"""Utility, info, fun, tag, report, chatbot commands."""
from __future__ import annotations

import asyncio
import logging
import random
import re
import time

import aiohttp
import httpx
from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Update
from telegram.constants import ParseMode
from telegram.error import BadRequest, Forbidden
from telegram.ext import CommandHandler, ContextTypes

from bot import db
from bot.config import OWNER_ID, DEFAULT_WELCOME, DEFAULT_GOODBYE, DEFAULT_RULES, OPENWEATHER_API_KEY
from bot.constants import E, MSG, to_persian, HELP_TEXT
from bot.decorators import admin_only
from bot.helpers import (
    resolve_target, user_link, is_chat_admin, extract_user,
    format_user_mention, user_id, timestamp_now,
    get_chat_member_count, format_welcome_message, chunk_list,
)
from bot.persian_router import register_mixed, register_persian

logger = logging.getLogger(__name__)


# ═══════════════════════════════════════════════
#  1. Info
# ═══════════════════════════════════════════════

async def info_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    chat = update.effective_chat
    target = await resolve_target(context.bot, update.message) or update.effective_user.id
    try:
        user = await context.bot.get_chat(target)
    except BadRequest:
        await update.message.reply_text("❌ این کاربر رو پیدا نکردم!")
        return
    is_bot = "✅" if user.is_bot else "❌"
    admin_status = ""
    if chat.type not in ("private", "channel"):
        try:
            member = await context.bot.get_chat_member(chat.id, target)
            admin_status = "👮 ادمین" if member.status in ("creator", "administrator") else "👤 کاربر"
        except (BadRequest, Forbidden):
            admin_status = "👤 کاربر"
    msgs = ""
    try:
        top = await db.get_top_users(chat.id, 9999)
        my_msgs = next((m["msg_count"] for m in top if m["user_id"] == target), 0)
        msgs = f"💬 پیام‌ها: {my_msgs}\n"
    except Exception:
        pass
    text = (
        f"ℹ️ <b>اطلاعات کاربر</b>\n"
        f"━━━━━━━━━━━━━━━\n"
        f"👤 نام: {format_user_mention(user)}\n"
        f"🆔 آیدی: <code>{user.id}</code>\n"
        f"🤖 ربات: {is_bot}\n"
    )
    if user.username:
        text += f"📛 یوزرنیم: @{user.username}\n"
    if admin_status:
        text += f"{admin_status}\n"
    text += msgs
    text += f"🔗 <a href='tg://user?id={user.id}'>لینک پروفایل</a>"
    await update.message.reply_text(text, parse_mode=ParseMode.HTML, disable_web_page_preview=True)


# ═══════════════════════════════════════════════
#  2. ID
# ═══════════════════════════════════════════════

async def id_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    chat = update.effective_chat
    user = update.effective_user
    text = f"🆔 <b>شناسه‌ها</b>\n━━━━━━━━━━━━━━━\n👤 شما: <code>{user.id}</code>\n"
    if chat.type != "private":
        text += f"💬 گروه: <code>{chat.id}</code>\n"
    reply = update.message.reply_to_message
    if reply and reply.from_user:
        text += f"👤 ریپلای شده: <code>{reply.from_user.id}</code>\n"
    if reply and reply.forward_origin:
        try:
            if reply.forward_origin.type == "user":
                text += f"📨 فرستاده اصلی: <code>{reply.forward_origin.sender_user.id}</code>\n"
        except Exception:
            pass
    await update.message.reply_text(text, parse_mode=ParseMode.HTML)


# ═══════════════════════════════════════════════
#  3. Group Info
# ═══════════════════════════════════════════════

async def groupinfo_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    chat = update.effective_chat
    if chat.type == "private":
        await update.message.reply_text("❌ این دستور فقط تو گروه کار میکنه!")
        return
    try:
        full = await context.bot.get_chat(chat.id)
    except BadRequest:
        await update.message.reply_text("❌ خطا در دریافت اطلاعات گروه")
        return
    admins = []
    try:
        admins = await context.bot.get_chat_administrators(chat.id)
    except (BadRequest, Forbidden):
        pass
    admin_count = len([a for a in admins if not a.user.is_bot])
    member_count = full.member_count or 0
    text = (
        f"ℹ️ <b>مشخصات گروه</b>\n"
        f"━━━━━━━━━━━━━━━\n"
        f"📌 نام: {full.title}\n"
        f"🆔 آیدی: <code>{full.id}</code>\n"
        f"👥 اعضا: {member_count} نفر\n"
        f"👮 ادمین‌ها: {admin_count} نفر\n"
        f"🏷 نوع: {full.type}\n"
    )
    if full.username:
        text += f"📛 یوزرنیم: @{full.username}\n"
    if full.description:
        desc = full.description[:100]
        text += f"📝 توضیحات: {desc}\n"
    if full.invite_link:
        text += f"🔗 لینک: {full.invite_link}\n"
    await update.message.reply_text(text, parse_mode=ParseMode.HTML, disable_web_page_preview=True)


# ═══════════════════════════════════════════════
#  4. Stats
# ═══════════════════════════════════════════════

async def stats_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    chat = update.effective_chat
    if chat.type == "private":
        await update.message.reply_text("❌ این دستور فقط تو گروه کار میکنه!")
        return
    top = await db.get_top_users(chat.id, 10)
    total_msgs = await db.get_chat_total_msgs(chat.id) if hasattr(db, 'get_chat_total_msgs') else sum(t["msg_count"] for t in top)
    chat_users = await db.get_chat_user_count(chat.id) if hasattr(db, 'get_chat_user_count') else 0
    text = (
        f"📊 <b>آمار گروه</b>\n"
        f"━━━━━━━━━━━━━━━\n"
        f"💬 مجموع پیام‌ها: {total_msgs}\n"
        f"👥 کاربران فعال: {chat_users}\n\n"
        f"<b>فعال‌ترین کاربران:</b>\n"
    )
    medals = ["🥇", "🥈", "🥉"]
    for i, t in enumerate(top):
        medal = medals[i] if i < 3 else f"{i+1}."
        try:
            u = await context.bot.get_chat(t["user_id"])
            name = u.first_name or str(t["user_id"])
        except BadRequest:
            name = str(t["user_id"])
        text += f"{medal} <a href='tg://user?id={t['user_id']}'>{name}</a> — {t['msg_count']} پیام\n"
    await update.message.reply_text(text, parse_mode=ParseMode.HTML, disable_web_page_preview=True)


# ═══════════════════════════════════════════════
#  5. Tag
# ═══════════════════════════════════════════════

@admin_only
async def tag_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    chat = update.effective_chat
    if chat.type == "private":
        await update.message.reply_text("❌ این دستور فقط تو گروه کار میکنه!")
        return
    from bot.helpers import get_text_args
    text = get_text_args(update, context) or "📣 توجه همه اعضا!"
    try:
        member_count = await context.bot.get_chat_member_count(chat.id)
    except BadRequest:
        member_count = 0
    if member_count > 100:
        await update.message.reply_text(
            f"⚠️ گروه {member_count} تا عضو داره! برای جلوگیری از اسپم، "
            f"فقط ادمین‌ها تگ میشن.",
            parse_mode=ParseMode.HTML,
        )
        return
    try:
        admins = await context.bot.get_chat_administrators(chat.id)
    except BadRequest:
        await update.message.reply_text("❌ نمیتونم ادمین‌ها رو بگیرم.")
        return
    mentions = []
    for a in admins:
        u = a.user
        if u.is_bot:
            continue
        mentions.append(f"<a href='tg://user?id={u.id}'>{u.first_name}</a>")
    if not mentions:
        await update.message.reply_text("❌ کسی برای تگ کردن پیدا نکردم!")
        return
    header = f"📣 <b>{text}</b>\n\n" + "─" * 20 + "\n"
    for chunk in chunk_list(mentions, 50):
        try:
            await update.message.reply_text(header + " ".join(chunk), parse_mode=ParseMode.HTML)
        except (BadRequest, Forbidden) as e:
            await update.message.reply_text(f"❌ خطا: {e}")
            break
        await asyncio.sleep(0.5)


# ═══════════════════════════════════════════════
#  6. Report
# ═══════════════════════════════════════════════

async def report_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    if not update.message.reply_to_message:
        await update.message.reply_text("❌ روی پیام مورد نظر ریپلای کن!")
        return
    chat = update.effective_chat
    reporter = update.effective_user
    reported = update.message.reply_to_message
    try:
        admins = await context.bot.get_chat_administrators(chat.id)
    except BadRequest:
        await update.message.reply_text("❌ خطا در دریافت لیست ادمین‌ها.")
        return
    admin_mentions = []
    for a in admins:
        u = a.user
        if u.is_bot:
            continue
        admin_mentions.append(f"<a href='tg://user?id={u.id}'>{u.first_name}</a>")
    if not admin_mentions:
        await update.message.reply_text("❌ ادمینی در گروه پیدا نشد!")
        return
    try:
        await reported.forward(chat.id)
    except BadRequest:
        pass
    target_id = reported.from_user.id if reported.from_user else 0
    keyboard = InlineKeyboardMarkup([
        [
            InlineKeyboardButton("🔨 بن", callback_data=f"rpt_ban:{chat.id}:{target_id}"),
            InlineKeyboardButton("⚠️ اخطار", callback_data=f"rpt_warn:{chat.id}:{target_id}"),
            InlineKeyboardButton("❌ صرف نظر", callback_data="rpt_ignore"),
        ]
    ])
    text = (
        f"🚨 <b>گزارش!</b>\n\n"
        f"گزارش‌دهنده: {user_link(reporter)}\n"
        f"متخلف: {user_link(reported.from_user) if reported.from_user else 'نامشخص'}\n"
        f"لینک پیام: <a href='{reported.link}'>مشاهده</a>\n\n"
        f"ادمین‌ها: " + " ".join(admin_mentions[:5])
    )
    await update.message.reply_text(text, parse_mode=ParseMode.HTML, reply_markup=keyboard)


# ═══════════════════════════════════════════════
#  7. Rules
# ═══════════════════════════════════════════════

async def rules_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    text = await db.get_setting(update.effective_chat.id, "rules", default=DEFAULT_RULES)
    await update.message.reply_text(
        f"📜 <b>قوانین گروه</b>\n━━━━━━━━━━━━━━━\n\n{text}",
        parse_mode=ParseMode.HTML,
    )


@admin_only
async def setrules_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    from bot.helpers import get_text_args
    text = get_text_args(update, context)
    if not text:
        await update.message.reply_text(
            "❌ بعد از دستور، متن قوانین رو بنویس!",
            parse_mode=ParseMode.HTML,
        )
        return
    await db.set_setting(update.effective_chat.id, "rules", text)
    await update.message.reply_text(
        f"✅ قوانین جدید تنظیم شد:\n\n{text}",
        parse_mode=ParseMode.HTML,
    )


@admin_only
async def delrules_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await db.del_setting(update.effective_chat.id, "rules")
    await update.message.reply_text("✅ قوانین حذف شد! برای تنظیم مجدد از /setrules استفاده کن.")


# ═══════════════════════════════════════════════
#  8. Welcome
# ═══════════════════════════════════════════════

async def welcome_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    settings = await db.get_all_settings(update.effective_chat.id)
    enabled = settings.get("welcome_enabled", "1") == "1"
    text = settings.get("welcome_text", DEFAULT_WELCOME)
    state = "✅ فعال" if enabled else "❌ غیرفعال"
    await update.message.reply_text(
        f"👋 <b>خوش‌آمد</b> ({state})\n━━━━━━━━━━━━━━━\n\n{text}",
        parse_mode=ParseMode.HTML,
    )


@admin_only
async def setwelcome_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    from bot.helpers import get_text_args
    text = get_text_args(update, context)
    if not text:
        await update.message.reply_text(
            "❌ بعد از دستور، متن خوش‌آمد رو بنویس!\n\n"
            "متغیرها:\n"
            "<code>{first}</code> نام\n"
            "<code>{last}</code> نام خانوادگی\n"
            "<code>{fullname}</code> نام کامل\n"
            "<code>{username}</code> یوزرنیم\n"
            "<code>{mention}</code> منشن\n"
            "<code>{id}</code> آیدی\n"
            "<code>{chat}</code> نام گروه\n"
            "<code>{count}</code> تعداد اعضا",
            parse_mode=ParseMode.HTML,
        )
        return
    await db.set_setting(update.effective_chat.id, "welcome_text", text)
    await db.set_setting(update.effective_chat.id, "welcome_enabled", "1")
    await update.message.reply_text(
        f"✅ خوش‌آمد جدید تنظیم شد:\n\n{text}",
        parse_mode=ParseMode.HTML,
    )


@admin_only
async def delwelcome_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await db.del_setting(update.effective_chat.id, "welcome_text")
    await db.set_setting(update.effective_chat.id, "welcome_enabled", "1")
    await update.message.reply_text(
        f"✅ خوش‌آمد به حالت پیش‌فرض برگشت:\n\n{DEFAULT_WELCOME}",
        parse_mode=ParseMode.HTML,
    )


# ═══════════════════════════════════════════════
#  9. Goodbye
# ═══════════════════════════════════════════════

async def goodbye_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    settings = await db.get_all_settings(update.effective_chat.id)
    enabled = settings.get("goodbye_enabled", "0") == "1"
    text = settings.get("goodbye_text", DEFAULT_GOODBYE)
    state = "✅ فعال" if enabled else "❌ غیرفعال"
    await update.message.reply_text(
        f"😢 <b>خداحافظی</b> ({state})\n━━━━━━━━━━━━━━━\n\n{text}",
        parse_mode=ParseMode.HTML,
    )


@admin_only
async def setgoodbye_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    from bot.helpers import get_text_args
    text = get_text_args(update, context)
    if not text:
        await update.message.reply_text(
            "❌ بعد از دستور، متن خداحافظی رو بنویس!",
            parse_mode=ParseMode.HTML,
        )
        return
    await db.set_setting(update.effective_chat.id, "goodbye_text", text)
    await db.set_setting(update.effective_chat.id, "goodbye_enabled", "1")
    await update.message.reply_text(
        f"✅ خداحافظی جدید تنظیم شد:\n\n{text}",
        parse_mode=ParseMode.HTML,
    )


@admin_only
async def delgoodbye_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await db.del_setting(update.effective_chat.id, "goodbye_text")
    await db.set_setting(update.effective_chat.id, "goodbye_enabled", "0")
    await update.message.reply_text(
        f"✅ خداحافظی حذف شد! مقدار پیش‌فرض:\n\n{DEFAULT_GOODBYE}",
        parse_mode=ParseMode.HTML,
    )


# ═══════════════════════════════════════════════
#  10. Translate
# ═══════════════════════════════════════════════

async def translate_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    msg = update.message
    from bot.helpers import get_text_args
    raw = get_text_args(update, context)
    source_text = None
    target_lang = "fa"

    if msg.reply_to_message:
        source_text = msg.reply_to_message.text or msg.reply_to_message.caption
        if raw:
            target_lang = raw.split()[0].lower() if raw.split() else "fa"
    elif raw:
        if raw.lower().startswith(">en"):
            target_lang = "en"
            source_text = raw[3:].strip()
        else:
            source_text = raw

    if not source_text:
        await msg.reply_text(
            "🌐 <b>ترجمه</b>\n\n"
            "متن رو بنویس یا روی پیام ریپلای کن!\n"
            "مثال: <code>ترجمه سلام خوبی</code>\n"
            "مثال: <code>ترجمه >en سلام خوبی</code>",
            parse_mode=ParseMode.HTML,
        )
        return

    status = await msg.reply_text(f"{E['loading']} دارم ترجمه می‌کنم...")
    try:
        url = (
            f"https://translate.googleapis.com/translate_a/single"
            f"?client=gtx&sl=auto&tl={target_lang}&dt=t&q={httpx.adapters.quote(source_text[:5000])}"
        )
        async with httpx.AsyncClient(timeout=10) as client:
            r = await client.get(url)
            r.raise_for_status()
            data = r.json()
        parts_out = []
        for segment in data[0]:
            if segment[0]:
                parts_out.append(segment[0])
        result = "".join(parts_out) if parts_out else None
    except Exception as e:
        logger.warning(f"Translate error: {e}")
        result = None

    if not result:
        await status.edit_text("❌ ترجمه انجام نشد! بعداً امتحان کن.")
        return

    lang_names = {"fa": "فارسی", "en": "انگلیسی", "ar": "عربی", "de": "آلمانی", "fr": "فرانسوی", "tr": "ترکی"}
    name = lang_names.get(target_lang, target_lang.upper())
    await status.edit_text(
        f"🌐 <b>ترجمه شده به {name}</b>\n━━━━━━━━━━━━━━━\n\n{result}",
        parse_mode=ParseMode.HTML,
    )


# ═══════════════════════════════════════════════
#  11. Weather
# ═══════════════════════════════════════════════

WEATHER_FA = {
    "clear sky": "آسمان صاف", "few clouds": "کمی ابری",
    "scattered clouds": "ابرهای پراکنده", "broken clouds": "ابری",
    "overcast clouds": "تمام ابری", "light rain": "باران سبک",
    "moderate rain": "باران متوسط", "heavy rain": "باران شدید",
    "thunderstorm": "طوفان", "snow": "برف", "light snow": "برف سبک",
    "mist": "مه", "fog": "مه غلیظ", "haze": "گرد و غبار",
    "drizzle": "نم نم باران",
}
WEATHER_EMOJI = {
    "clear": "☀️", "clouds": "☁️", "rain": "🌧️", "drizzle": "🌦️",
    "thunderstorm": "⛈️", "snow": "❄️", "mist": "🌫️", "fog": "🌫️", "haze": "🌫️",
}


def _trans_weather(desc: str) -> str:
    return WEATHER_FA.get(desc.lower(), desc)


def _weather_emoji(desc: str) -> str:
    for k, v in WEATHER_EMOJI.items():
        if k in desc.lower():
            return v
    return "🌤️"


async def weather_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    if not OPENWEATHER_API_KEY:
        await update.message.reply_text(
            "⚠️ کلید API آب و هوا تنظیم نشده!\n"
            "در فایل .env اضافه کن:\n"
            "<code>OPENWEATHER_API_KEY=your_key</code>",
            parse_mode=ParseMode.HTML,
        )
        return
    from bot.helpers import get_text_args
    city = get_text_args(update, context)

    if not city:
        await update.message.reply_text(
            "🌤 <b>آب و هوا</b>\n\n"
            "نام شهر رو بنویس!\n"
            "مثال: <code>/weather تهران</code>",
            parse_mode=ParseMode.HTML,
        )
        return

    mc = await update.message.reply_text(f"{E['loading']} دریافت اطلاعات آب و هوا...")
    try:
        async with aiohttp.ClientSession() as session:
            url = (
                f"https://api.openweathermap.org/data/2.5/weather"
                f"?q={city}&appid={OPENWEATHER_API_KEY}&units=metric&lang=fa"
            )
            async with session.get(url, timeout=aiohttp.ClientTimeout(total=10)) as resp:
                if resp.status != 200:
                    await mc.edit_text(f"❌ شهر «{city}» پیدا نشد!")
                    return
                data = await resp.json()
        temp = data["main"]["temp"]
        feels = data["main"]["feels_like"]
        humidity = data["main"]["humidity"]
        wind = data["wind"]["speed"]
        desc = data["weather"][0]["description"]
        city_name = data["name"]
        country = data["sys"]["country"]
        emoji = _weather_emoji(desc)
        desc_fa = _trans_weather(desc)
        text = (
            f"{emoji} <b>آب و هوای {city_name}, {country}</b>\n"
            f"━━━━━━━━━━━━━━━\n"
            f"🌡 دما: <b>{temp}°C</b>\n"
            f"🤗 حس واقعی: {feels}°C\n"
            f"💧 رطوبت: {humidity}%\n"
            f"💨 باد: {wind} m/s\n"
            f"☁️ وضعیت: {desc_fa}"
        )
        await mc.edit_text(text, parse_mode=ParseMode.HTML)
    except aiohttp.ClientError:
        await mc.edit_text("❌ خطا در اتصال به سرور آب و هوا!")
    except Exception as e:
        logger.warning(f"Weather error: {e}")
        await mc.edit_text("❌ خطای غیرمنتظره!")


# ═══════════════════════════════════════════════
#  12. Help
# ═══════════════════════════════════════════════

async def help_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text(HELP_TEXT, parse_mode=ParseMode.HTML, disable_web_page_preview=True)


# ═══════════════════════════════════════════════
#  13. Fun
# ═══════════════════════════════════════════════

async def dice_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    try:
        await update.message.reply_dice()
    except BadRequest:
        dice = random.randint(1, 6)
        faces = ["⚀", "⚁", "⚂", "⚃", "⚄", "⚅"]
        await update.message.reply_text(f"🎲 {faces[dice-1]} {to_persian(str(dice))}")


async def coin_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    result = random.choice(["شیر", "خط"])
    emoji = "🦁" if result == "شیر" else "👑"
    await update.message.reply_text(f"{emoji} {result}")


async def choose_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    from bot.helpers import get_text_args
    args_text = get_text_args(update, context)
    if not args_text:
        await update.message.reply_text(
            "❌ گزینه‌ها رو با ویرگول جدا کن!\n"
            "مثال: <code>انتخاب کن پیتزا, کباب, سالاد</code>",
            parse_mode=ParseMode.HTML,
        )
        return
    options = [o.strip() for o in args_text.split("،") if o.strip()]
    if len(options) < 2:
        options = [o.strip() for o in args_text.split(",") if o.strip()]
    if len(options) < 2:
        await update.message.reply_text("❌ حداقل دو گزینه بده!")
        return
    chosen = random.choice(options)
    await update.message.reply_text(f"🎯 انتخاب من: <b>{chosen}</b> 🎉", parse_mode=ParseMode.HTML)


# ═══════════════════════════════════════════════
#  14. AI Assistant
# ═══════════════════════════════════════════════

async def ai_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    from bot.helpers import get_text_args
    prompt = get_text_args(update, context)
    if not prompt:
        await update.message.reply_text(
            "🤖 <b>هوش مصنوعی</b>\n\n"
            "سوالت رو بپرس!\n"
            "مثال: <code>/ai بهترین زبان برنامه‌نویسی چیه؟</code>\n"
            "فارسی: <code>بپرس هوای فردا چطوره؟</code>",
            parse_mode=ParseMode.HTML,
        )
        return
    mc = await update.message.reply_text(f"{E['loading']} در حال فکر کردن...")
    try:
        try:
            from google import genai
            from google.genai import types
            from bot.config import os as config_os
            api_key = config_os.getenv("GEMINI_API_KEY", "")
            if not api_key:
                await mc.edit_text("❌ هوش مصنوعی در دسترس نیست. GEMINI_API_KEY رو تنظیم کن!")
                return
            client = genai.Client(api_key=api_key)
            sys_prompt = (
                "تو ربات تلگرامی bobi هستی. فقط به فارسی روان و خودمونی جواب بده. "
                "جواب مختصر باشه (حداکثر ۳-۴ خط). دوستانه و بامزه صحبت کن."
            )
            resp = await client.aio.models.generate_content(
                model="gemini-2.0-flash",
                contents=f"{sys_prompt}\n\nکاربر: {prompt}\n\nبابی:",
                config=types.GenerateContentConfig(temperature=0.7, max_output_tokens=1024),
            )
            answer = resp.text.strip() if resp and resp.text else None
        except ImportError:
            answer = None
        except Exception:
            answer = None

        if not answer:
            answer = f"سوال خوبی پرسیدی! من bobi هستم و فعلاً هوش مصنوعی پیشرفته در دسترس نیست. برای پرسیدن سوالات مدیریتی می‌تونی از دستورات دیگه استفاده کنی!"

        if len(answer) > 4000:
            answer = answer[:4000] + "\n\n..."
        await mc.edit_text(
            f"🤖 <b>پاسخ bobi:</b>\n\n{answer}",
            parse_mode=ParseMode.HTML,
        )
    except Exception as e:
        logger.exception(f"AI error: {e}")
        await mc.edit_text("❌ خطایی رخ داد! بعداً امتحان کن.")


# ═══════════════════════════════════════════════
#  15. Ping
# ═══════════════════════════════════════════════

async def ping_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    start = time.perf_counter()
    mc = await update.message.reply_text(f"{E['loading']} پینگ...")
    end = time.perf_counter()
    ms = int((end - start) * 1000)
    if ms < 200:
        status = "عالی 🚀"
    elif ms < 500:
        status = "خوب ✅"
    elif ms < 1000:
        status = "قابل قبول ⚠️"
    else:
        status = "ضعیف 🔴"
    await mc.edit_text(
        f"🏓 <b>پونگ!</b>\n"
        f"━━━━━━━━━━━━━━━\n"
        f"⏱ {to_persian(str(ms))} میلی‌ثانیه\n"
        f"📶 وضعیت: {status}",
        parse_mode=ParseMode.HTML,
    )


# ═══════════════════════════════════════════════
#  16. Chatbot Toggle
# ═══════════════════════════════════════════════

@admin_only
async def chatbot_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    chat = update.effective_chat
    if chat.type == "private":
        await update.message.reply_text("ℹ️ چت خصوصی همیشه فعاله!")
        return
    current = await db.get_setting(chat.id, "chatbot_enabled", "0")
    if current == "1":
        await db.set_setting(chat.id, "chatbot_enabled", "0")
        await update.message.reply_text("✅ چت‌بات غیرفعال شد!")
    else:
        await db.set_setting(chat.id, "chatbot_enabled", "1")
        await update.message.reply_text("✅ چت‌بات فعال شد! می‌تونم باهات حرف بزنم!")


# ═══════════════════════════════════════════════
#  17. Chat Message Handler (listener pipeline)
# ═══════════════════════════════════════════════

async def on_chat_message(update: Update, context: ContextTypes.DEFAULT_TYPE) -> bool:
    if not update.message or not update.message.text:
        return False
    chat = update.effective_chat
    if not chat or chat.type == "private":
        return False
    setting = await db.get_setting(chat.id, "chatbot_enabled", "0")
    if setting != "1":
        return False
    bot_username = context.bot.username or ""
    text = (update.message.text or "").strip().lower()
    if not text or text.startswith("/"):
        return False
    is_reply_to_bot = (
        update.message.reply_to_message
        and update.message.reply_to_message.from_user
        and update.message.reply_to_message.from_user.id == context.bot.id
    )
    is_mentioned = bot_username and f"@{bot_username.lower()}" in text
    is_direct = chat.type == "private"
    if not (is_reply_to_bot or is_mentioned or is_direct):
        return False

    try:
        result = await db.brain.match(chat.id, text)
        if result:
            response = db.brain.apply_template(
                result.response.response,
                user=update.effective_user,
                chat=update.effective_chat,
            )
            if "||" in response and result.response.media_type == "text":
                response = random.choice([p.strip() for p in response.split("||")])
            if result.response.delay > 0:
                await asyncio.sleep(result.response.delay)
            try:
                await update.message.reply_text(response, parse_mode=ParseMode.HTML)
            except (BadRequest, Forbidden):
                await update.message.reply_text(response)
            return True
    except Exception:
        pass

    try:
        qa_answer = await db.find_qa(chat.id, text)
        if qa_answer:
            await update.message.reply_text(qa_answer)
            return True
    except Exception:
        pass

    return False


# ═══════════════════════════════════════════════
#  Registration
# ═══════════════════════════════════════════════

def register(app) -> None:
    register_mixed(app, {
        "info": info_cmd, "id": id_cmd, "groupinfo": groupinfo_cmd, "stats": stats_cmd,
        "tag": tag_cmd, "report": report_cmd, "rules": rules_cmd, "setrules": setrules_cmd,
        "delrules": delrules_cmd, "welcome": welcome_cmd, "setwelcome": setwelcome_cmd,
        "delwelcome": delwelcome_cmd, "goodbye": goodbye_cmd, "setgoodbye": setgoodbye_cmd,
        "delgoodbye": delgoodbye_cmd, "translate": translate_cmd, "tr": translate_cmd,
        "weather": weather_cmd, "wthr": weather_cmd, "help": help_cmd, "start": help_cmd,
        "dice": dice_cmd, "coin": coin_cmd, "choose": choose_cmd,
        "ai": ai_cmd, "ask": ai_cmd, "ping": ping_cmd, "chatbot": chatbot_cmd,
    }, {
        "اطلاعات": info_cmd, "پروفایل": info_cmd, "آیدی": id_cmd,
        "اطلاعات گروه": groupinfo_cmd, "مشخصات گروه": groupinfo_cmd,
        "آمار": stats_cmd, "فعال‌ترین": stats_cmd,
        "تگ کن": tag_cmd, "همگانی": tag_cmd, "همه": tag_cmd,
        "گزارش": report_cmd, "شکایت": report_cmd,
        "قوانین": rules_cmd, "قوانین گروه": rules_cmd,
        "تنظیم قوانین": setrules_cmd, "قانون جدید": setrules_cmd,
        "حذف قوانین": delrules_cmd, "پاک کردن قوانین": delrules_cmd,
        "خوشامد": welcome_cmd, "پیام خوشامد": welcome_cmd, "خوش‌آمد": welcome_cmd,
        "تنظیم خوشامد": setwelcome_cmd,
        "حذف خوشامد": delwelcome_cmd, "بازنشانی": delwelcome_cmd,
        "خداحافظی": goodbye_cmd, "متن خداحافظی": goodbye_cmd,
        "تنظیم خداحافظی": setgoodbye_cmd, "حذف خداحافظی": delgoodbye_cmd,
        "ترجمه": translate_cmd, "برگردون": translate_cmd, "برگردان": translate_cmd,
        "هوا": weather_cmd, "آب و هوا": weather_cmd, "هواشناسی": weather_cmd,
        "راهنما": help_cmd, "کمک": help_cmd,
        "تاس": dice_cmd, "بینداز تاس": dice_cmd,
        "سکه": coin_cmd, "شیر یا خط": coin_cmd,
        "انتخاب کن": choose_cmd, "انتخابت کن": choose_cmd,
        "هوش مصنوعی": ai_cmd, "بپرس": ai_cmd, "سوال": ai_cmd,
        "پینگ": ping_cmd, "چه خبر": ping_cmd,
        "چت‌بات": chatbot_cmd, "هوشمند": chatbot_cmd,
    })