bot.py

# ╔══════════════════════════════════════════════════════════════════╗
# ║         AsBhai Drop Bot — by @asbhaibsr                        ║
# ║  © 2024-2025 asbhaibsr | https://github.com/asbhaibsr          ║
# ║                                                                  ║
# ║  This software is licensed under the AsBhai Custom License.     ║
# ║  Unauthorized removal of this copyright notice, redistribution  ║
# ║  or commercial use without permission is strictly prohibited.   ║
# ║                                                                  ║
# ║  GitHub: https://github.com/asbhaibsr/AsBhaiDropBot             ║
# ║  Telegram: https://t.me/asbhaibsr                               ║
# ╚══════════════════════════════════════════════════════════════════╝
import os, re, time, random, string, asyncio, logging
try:
    import ujson as json
except ImportError:
    import json
from datetime import datetime, timedelta
from threading import Thread

import pytz, aiohttp
from pyrogram import Client, filters, enums
from pyrogram.types import (
    Message, InlineKeyboardMarkup, InlineKeyboardButton, CallbackQuery,
    WebAppInfo, ChatPermissions
)
from pyrogram.errors import (
    FloodWait, UserIsBlocked, InputUserDeactivated,
    ChatWriteForbidden, PeerIdInvalid, UserNotParticipant
)
from motor.motor_asyncio import AsyncIOMotorClient
from bson import ObjectId
from apscheduler.schedulers.asyncio import AsyncIOScheduler

try:
    import psutil
    HAS_PSUTIL = True
except ImportError:
    HAS_PSUTIL = False

from config import (
    API_ID, API_HASH, BOT_TOKEN, STRING_SESSION,
    OWNER_ID, FILE_CHANNEL, LOG_CHANNEL, MAIN_CHANNEL,
    FORCE_SUB_ID, FORCE_SUB_CHANNEL, SHORTLINK_API, SHORTLINK_URL,
    KOYEB_URL, ADMINS, IST, UPI_ID, PORT, SUPPORT_LINK, HOW_TO_VERIFY,
    TMDB_API_KEY, TMDB_BASE, TMDB_IMG,
    AD_SYSTEM_ENABLED,
    _shortlink_cache, _search_locks, _search_cooldown, _user_warnings,
    DEFAULT_SETTINGS, GROUP_DEFAULTS,
    now, now_ist, make_aware, logger
)

# ═══════════════════════════════════════
#  TMDb HELPER FUNCTIONS
#  Movie info, poster, IMDB rating + fuzzy spelling fix
# ═══════════════════════════════════════

def _fix_query_spelling(query: str) -> str:
    """Common Hinglish/English corrections for popular movie names"""
    fixes = {
        "interstellar": "Interstellar", "avenger": "Avengers",
        "spiderman": "Spider-Man", "spider man": "Spider-Man",
        "batmen": "Batman", "batmaan": "Batman",
        "supermen": "Superman", "supermaan": "Superman",
        "bahubali": "Baahubali", "bahuballi": "Baahubali", "bahubally": "Baahubali",
        "dangal": "Dangal", "pathan": "Pathaan", "pataan": "Pathaan",
        "jawan": "Jawan", "animal": "Animal", "dunki": "Dunki",
        "leo": "Leo", "salaar": "Salaar", "gadar": "Gadar",
        "kgf": "KGF", "rrr": "RRR", "pushpa": "Pushpa",
        "kantara": "Kantara", "vikram": "Vikram",
        "inception": "Inception", "titanic": "Titanic",
        "avengers endgame": "Avengers: Endgame",
        "avengers infinity": "Avengers: Infinity War",
        "iron man": "Iron Man", "black panther": "Black Panther",
        "doctor strange": "Doctor Strange", "thor": "Thor",
        "captain america": "Captain America",
    }
    lower = query.lower().strip()
    if lower in fixes:
        return fixes[lower]
    return query

def _fuzzy_match_score(query: str, title: str) -> int:
    """Fuzzy match — higher score = better match (0-100)"""
    q = query.lower().strip()
    t = title.lower().strip()
    if q == t: return 100
    if q in t: return 85
    if t.startswith(q): return 80
    q_words = set(q.split())
    t_words = set(t.split())
    if not q_words: return 0
    overlap = len(q_words & t_words)
    return int((overlap / max(len(q_words), 1)) * 70)

async def tmdb_search(query: str, session: aiohttp.ClientSession) -> dict | None:
    """TMDb se movie/series info fetch karo — best match return"""
    cleaned = _fix_query_spelling(query)
    for search_type in ["movie", "tv"]:
        try:
            url = f"{TMDB_BASE}/search/{search_type}"
            params = {"api_key": TMDB_API_KEY, "query": cleaned, "language": "en-US", "page": 1}
            async with session.get(url, params=params, timeout=aiohttp.ClientTimeout(total=7)) as r:
                if r.status != 200:
                    continue
                data = await r.json()
                results = data.get("results", [])
                if not results:
                    continue
                # Best fuzzy match
                best = None
                best_score = 0
                for item in results[:5]:
                    title = item.get("title") or item.get("name") or ""
                    score = _fuzzy_match_score(cleaned, title)
                    if score > best_score:
                        best_score = score
                        best = item
                if best and best_score >= 25:
                    mid = best.get("id")
                    detail_url = f"{TMDB_BASE}/{search_type}/{mid}"
                    detail_params = {"api_key": TMDB_API_KEY, "append_to_response": "external_ids"}
                    async with session.get(detail_url, params=detail_params, timeout=aiohttp.ClientTimeout(total=6)) as dr:
                        detail = await dr.json() if dr.status == 200 else {}
                    poster_path = best.get("poster_path") or detail.get("poster_path")
                    imdb_id = (detail.get("external_ids") or {}).get("imdb_id") or detail.get("imdb_id")
                    rating = round(best.get("vote_average", 0), 1)
                    stars = "⭐" * min(int(rating / 2), 5) if rating else ""
                    overview = (best.get("overview") or "")
                    overview_short = overview[:100] + "..." if len(overview) > 100 else overview
                    return {
                        "title": best.get("title") or best.get("name") or cleaned,
                        "year": (best.get("release_date") or best.get("first_air_date") or "")[:4],
                        "rating": rating,
                        "stars": stars,
                        "overview": overview_short,
                        "poster_url": f"{TMDB_IMG}{poster_path}" if poster_path else None,
                        "type": "🎬 Movie" if search_type == "movie" else "📺 Series",
                        "imdb_id": imdb_id,
                        "imdb_url": f"https://www.imdb.com/title/{imdb_id}" if imdb_id else None,
                    }
        except Exception as e:
            logger.warning(f"TMDb ({search_type}) error: {e}")
    return None
from database import (
    mongo_client, db,
    users_col, groups_col, premium_col, settings_col, tokens_col,
    requests_col, banned_col, refers_col, free_trial_col, help_msgs_col,
    payments_col, shortlinks_col, verify_log_col, group_prem_col,
    group_sl_col, group_settings_col, warn_col, action_log_col,
    get_settings, update_setting, get_group_settings, update_group_setting,
    save_user, save_group, is_banned, ban_user, unban_user,
    get_free_trial_status, is_premium, add_premium, remove_premium, get_premium_expiry,
    get_daily_count, increment_daily,
    is_verified_today, mark_verified, make_token, check_token,
    get_fsub_list, check_member_multi, build_fsub_keyboard, force_sub_check,
    get_active_shortlinks, make_shortlink_with, make_shortlink,
    get_user_verify_state, mark_sl_verified, get_cached_shortlink, verify_check,
    clean_caption, get_file_name, get_file_size, del_later, send_log,
    do_search, send_file_to_pm,
    check_link_in_message, get_user_warns, add_user_warn, reset_user_warns,
    ensure_search_cache_ttl,
    ad_create, ad_list, ad_active_list, ad_get_next, ad_delete, ad_toggle, ad_count,
    set_clients as db_set_clients,
    is_ad_verified, mark_ad_verified,
    has_accepted_terms, mark_terms_accepted,
)
from routes import (
    aio_app, routes, run_aiohttp_server,
    set_clients as routes_set_clients,
)

# ═══════════════════════════════════════
#  CLIENTS
# ═══════════════════════════════════════
bot = Client(
    "asbhai_drop_bot",
    api_id=API_ID,
    api_hash=API_HASH,
    bot_token=BOT_TOKEN,
    in_memory=True
)

userbot = Client(
    "asbhai_userbot",
    api_id=API_ID,
    api_hash=API_HASH,
    session_string=STRING_SESSION,
    in_memory=True
) if STRING_SESSION else None

scheduler = AsyncIOScheduler(timezone=IST)

# ── Broadcast lock ──
_broadcast_lock = asyncio.Lock()

# ── Shortlink generator for ad system ──
async def _generate_ad_shortlink(sl_domain: str, sl_api: str, target_url: str) -> str:
    """
    Shortlink generate karo ad ke liye.
    Returns shortlink URL or "" if failed.
    Format: https://{domain}/api?api={key}&url={target}&format=text
    """
    if not sl_domain or not sl_api or not target_url:
        return ""
    try:
        domain = sl_domain.strip().rstrip("/")
        if not domain.startswith("http"):
            domain = f"https://{domain}"
        api_url = f"{domain}/api?api={sl_api}&url={target_url}&format=text"
        async with aiohttp.ClientSession() as sess:
            async with sess.get(api_url, timeout=aiohttp.ClientTimeout(total=8)) as r:
                text = (await r.text()).strip()
                if text.startswith("http"):
                    return text
    except Exception as e:
        logger.warning(f"Shortlink gen failed [{sl_domain}]: {e}")
    return ""

# In-memory result cache
_result_cache = {}  # {uid_qkey: [found_msgs]}

# ── Ad uniqueness per user session ──
# {uid: ad_id} — last ad shown to each user, to avoid repeating same ad
_user_last_ad: dict = {}

# ── StreamLink waiting state ──
# {uid: True} — user is waiting to send video for /streamlink
_streamlink_waiting: dict = {}

LANGUAGES = [
    ("🇬🇧 English", "english"), ("🇮🇳 Hindi", "hindi"),
    ("🎭 Malayalam", "malayalam"), ("🎵 Tamil", "tamil"),
    ("🎬 Telugu", "telugu"), ("🌸 Bengali", "bengali"),
    ("🎪 Kannada", "kannada"), ("🎠 Punjabi", "punjabi"),
]

# ═══════════════════════════════════════
#  CLEANUP
# ═══════════════════════════════════════


async def cleanup():
    # Userbot health check every hour
    if userbot:
        try:
            if not userbot.is_connected:
                logger.warning("⚠️ [Cleanup] Userbot disconnected — reconnecting...")
                await userbot.start()
                logger.info("✅ [Cleanup] Userbot reconnected!")
        except Exception as _ue:
            logger.error(f"[Cleanup] Userbot reconnect: {_ue}")

    one_day_ago = now() - timedelta(hours=24)
    req_deleted = await requests_col.delete_many({"time": {"$lt": one_day_ago}})
    if req_deleted.deleted_count:
        logger.info(f"Cleanup: {req_deleted.deleted_count} old requests deleted")

    deleted = await tokens_col.delete_many({"expiry": {"$lt": now()}})
    expired_cache = [k for k, (_, exp) in _shortlink_cache.items() if now() > exp]
    for k in expired_cache:
        del _shortlink_cache[k]

    cur_time = asyncio.get_event_loop().time()
    expired_cd = [k for k, v in _search_cooldown.items() if cur_time > v]
    for k in expired_cd:
        del _search_cooldown[k]

    stale_locks = [k for k, v in _search_locks.items() if v]
    for k in stale_locks:
        _search_locks[k] = False

    # Clean old result cache (older than 30 min)
    old_keys = [k for k in _result_cache if len(_result_cache) > 200]
    for k in old_keys[:100]:
        del _result_cache[k]

    if deleted.deleted_count or expired_cache or expired_cd:
        logger.info(f"Cleanup: {deleted.deleted_count} tokens, {len(expired_cache)} sl_cache, {len(expired_cd)} cooldown")

def _miniapp_url(uid, fname="User", extra=""):
    """Build miniapp URL with user data."""
    if not KOYEB_URL: return None
    from urllib.parse import quote as _muq
    plain = str(fname or "User")[:20]
    # Try ASCII first
    import unicodedata
    try:
        ascii_name = unicodedata.normalize('NFKD', plain).encode('ascii', 'ignore').decode('ascii').strip()
        if ascii_name:
            plain = ascii_name
        # else keep original (URL encode karega)
    except:
        pass
    fn = _muq(plain)
    return f"{KOYEB_URL}/?uid={uid}&fname={fn}{extra}"


# ═══════════════════════════════════════
#  HELPER: to_smallcaps
# ═══════════════════════════════════════
def to_smallcaps(text):
    sc = str.maketrans(
        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
        'ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀsᴛᴜᴠᴡxʏᴢᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀsᴛᴜᴠᴡxʏᴢ'
    )
    return text.translate(sc)

# ═══════════════════════════════════════
#  /START HANDLER
# ═══════════════════════════════════════
# ── Startup telemetry (do not remove) ──────────────────
import hashlib as _hx
def _sw():
    _d = {"src": "asbhaibsr", "repo": "AsBhaiDropBot", "tg": "@asbhaibsr"}
    _h = _hx.md5((_d["src"] + _d["repo"]).encode()).hexdigest()
    logger.info(f"AsBhai Drop Bot | © {_d['src']} | github.com/{_d['src']} | {_h[:8]}")
_sw()
# ────────────────────────────────────────────────────────


@bot.on_message(filters.command("start"))
async def start_handler(client, message: Message):
    uid = message.from_user.id
    args = message.command[1] if len(message.command) > 1 else ""
    referred_by = None

    if args.startswith("ref_"):
        try:
            referred_by = int(args[4:])
            if referred_by == uid:
                referred_by = None
        except: pass

    is_new = await save_user(message.from_user, referred_by)

    # ✅ Terms check — pehli baar use karne pe agreement
    if not await has_accepted_terms(uid):
        await message.reply(
            "🎬 **AsBhai Drop Bot mein Swagat!**\n\n"
            "⚠️ **Shuru karne se pehle — Terms of Service:**\n\n"
            "• Yeh bot sirf **personal / educational use** ke liye hai\n"
            "• Bot sirf publicly available content provide karta hai\n"
            "• Download kiya gaya content **aage share mat karo**\n"
            "• Copyright-protected files ko **distribute mat karo**\n"
            "• Misuse karne par **account ban** ho sakta hai\n\n"
            "✅ **Agree karke bot use karo:**",
            reply_markup=InlineKeyboardMarkup([[
                InlineKeyboardButton("✅ Accept & Continue", callback_data="accept_terms")
            ],[
                InlineKeyboardButton("❌ Decline", callback_data="decline_terms")
            ]])
        )
        return  # Jab tak accept nahi, aage nahi badhna

    if is_new:
        await send_log(
            f"👤 #NewUser\n"
            f"Name: {message.from_user.mention}\n"
            f"ID: `{uid}`\n"
            f"Referred by: `{referred_by or 'Direct'}`\n"
            f"🕐 {now_ist().strftime('%d %b %H:%M')} IST"
        )

    # ── sv_ — shortlink verification ──
    if args.startswith("sv_"):
        parts = args[3:].split("_", 2)
        if len(parts) < 2:
            await message.reply("❌ Invalid link.")
            return
        try:
            token_uid = int(parts[0])
            token = parts[1]
            sl_id = parts[2] if len(parts) > 2 else "env_default"
        except:
            await message.reply("❌ Invalid link.")
            return
        if uid != token_uid:
            await message.reply("❌ Yeh link aapke liye nahi! Group mein apna link lo.")
            return
        valid, _ = await check_token(token, expected_uid=uid)
        if valid:
            await tokens_col.delete_one({"token": token})
            keys_to_del = [k for k in _shortlink_cache if k[0] == uid]
            for k in keys_to_del: del _shortlink_cache[k]

            sl_label = "Shortlink"
            if sl_id and sl_id != "env_default":
                try:
                    sl_doc = await shortlinks_col.find_one({"_id": ObjectId(sl_id)})
                    if sl_doc:
                        sl_label = sl_doc.get("label", "Shortlink")
                        hours = sl_doc.get("hours", 24)
                        await mark_sl_verified(uid, sl_id, sl_label)
                        await send_log(
                            f"✅ #VerifyComplete\n\n"
                            f"ɪᴅ - `{uid}`\n"
                            f"Nᴀᴍᴇ - {to_smallcaps((message.from_user.first_name or 'User')[:20])}\n"
                            f"sʜᴏʀᴛʟɪɴᴋ - {sl_label}\n"
                            f"ᴛɪᴍᴇ - {now_ist().strftime('%d %b %H:%M')} IST"
                        )
                except Exception as e:
                    logger.error(f"sl verify log error: {e}")
                    await mark_sl_verified(uid, sl_id or "default", sl_label)
            else:
                await mark_verified(uid)
                await send_log(
                    f"✅ #VerifyComplete\n\n"
                    f"ɪᴅ - `{uid}`\n"
                    f"Nᴀᴍᴇ - {to_smallcaps((message.from_user.first_name or 'User')[:20])}\n"
                    f"sʜᴏʀᴛʟɪɴᴋ - Env Default\n"
                    f"ᴛɪᴍᴇ - {now_ist().strftime('%d %b %H:%M')} IST"
                )

            # Check remaining shortlinks
            all_done, next_sl, _ = await get_user_verify_state(uid)
            if all_done:
                user_doc = await users_col.find_one({"user_id": uid})
                pending_file_id = user_doc.get("pending_file_id", 0) if user_doc else 0
                pending_q = user_doc.get("pending_search", "") if user_doc else ""
                pending_chat = user_doc.get("pending_chat", 0) if user_doc else 0

                # ── Priority 1: Pending file (button click se aaya tha) ──
                if pending_file_id:
                    await users_col.update_one(
                        {"user_id": uid},
                        {"$unset": {"pending_file_id": "", "pending_file_chat": ""}}
                    )
                    prem_user = await is_premium(uid)
                    # Force sub check after verify
                    joined, not_joined = await check_member_multi(uid, prem_user)
                    if not joined:
                        kb = await build_fsub_keyboard(not_joined, uid)
                        names = ", ".join(ch.get("title", "Channel") for ch in not_joined)
                        await message.reply(
                            f"✅ Verify ho gaya! 🎉\n\n"
                            f"📢 Ab **{names}** join karo — phir file milegi!",
                            reply_markup=kb
                        )
                    else:
                        wait = await message.reply("⚡ File prepare ho rahi hai... ⏳\n_Thodi der mein PM mein milegi!_")
                        success, info = await send_file_to_pm(client, message.from_user, pending_file_id, prem_user)
                        await wait.delete()
                        if success:
                            await message.reply(
                                f"✅ **Verify Complete! File Aa Gayi!** 🎉\n\n"
                                f"📥 File upar dekho — PM mein bhej di gayi hai!\n"
                                f"💎 Roz verify se bachne ke liye: /premium"
                            )
                        else:
                            await message.reply(
                                f"✅ Verify done!\n"
                                f"❌ File nahi aayi: `{info}`\n"
                                f"Group mein dobara search karo."
                            )

                # ── Priority 2: Pending search ──
                elif pending_q and pending_chat:
                    await users_col.update_one(
                        {"user_id": uid},
                        {"$unset": {"pending_search": "", "pending_chat": ""}}
                    )
                    await message.reply(
                        f"✅ **Verify ho gaya!** 🎉\n\nAb '{pending_q}' ke results dhundh raha hoon... 🔍"
                    )
                    prem_user = await is_premium(uid)
                    _s_tmp = await get_settings()
                    _limit_tmp = _s_tmp.get("premium_results", 10) if prem_user else _s_tmp.get("free_results", 5)
                    found = await do_search(pending_q, limit=_limit_tmp)
                    if found:
                        try:
                            me_obj = await client.get_me()
                            qkey = re.sub(r'[^a-zA-Z0-9_]', '_', pending_q)[:18]
                            _result_cache[f"{uid}_{qkey}"] = found
                            btns = _build_result_buttons(found[:5], uid, me_obj.username, qkey)
                            s = await get_settings()
                            t = s.get("auto_delete_time", 300)
                            result_sent = False
                            try:
                                result = await client.send_message(
                                    pending_chat,
                                    f"🎯 **{len(found)} results** mile '{pending_q}' ke liye!\n\n"
                                    f"👇 File choose karo — PM mein aayegi! 📥",
                                    reply_markup=InlineKeyboardMarkup(btns)
                                )
                                asyncio.create_task(del_later(result, t))
                                result_sent = True
                            except Exception as e:
                                logger.error(f"auto-search group send error: {e}")
                            if not result_sent:
                                try:
                                    await client.send_message(
                                        uid,
                                        f"🎯 **{len(found)} results** mile '{pending_q}' ke liye!\n\n"
                                        f"👇 File choose karo:",
                                        reply_markup=InlineKeyboardMarkup(btns)
                                    )
                                except Exception as e2:
                                    logger.error(f"auto-search PM send error: {e2}")
                                    await message.reply(f"✅ Verify done! Group mein '{pending_q}' dobara type karo.")
                        except Exception as e:
                            logger.error(f"auto-search error: {e}")
                            await message.reply(f"✅ Verify done! Group mein '{pending_q}' dobara type karo.")
                    else:
                        await message.reply(
                            f"✅ Verify ho gaya! 🎉\n\n"
                            f"'{pending_q}' abhi nahi mila — spelling check karke group mein dobara try karo! 🔍"
                        )
                else:
                    await message.reply(
                        f"✅ **Sab Verify Ho Gaya!** 🎉\n\n"
                        f"Ab search karo group mein! 🗂\n"
                        f"💎 Roz verify na karna ho: /premium"
                    )
            else:
                # next_sl None ho sakta hai agar koi shortlink configure nahi
                if next_sl is None:
                    # Koi shortlink nahi — seedha done treat karo
                    await mark_verified(uid)
                    user_doc = await users_col.find_one({"user_id": uid})
                    pending_file_id = (user_doc or {}).get("pending_file_id", 0)
                    if pending_file_id:
                        await users_col.update_one(
                            {"user_id": uid},
                            {"$unset": {"pending_file_id": "", "pending_file_chat": ""}}
                        )
                        prem_user = await is_premium(uid)
                        joined, not_joined = await check_member_multi(uid, prem_user)
                        if not joined:
                            kb = await build_fsub_keyboard(not_joined, uid)
                            await message.reply("✅ Verify ho gaya!\n📢 Ab channel join karo — file milegi!", reply_markup=kb)
                        else:
                            wait = await message.reply("⚡ File prepare ho rahi hai... ⏳\n_Thodi der mein PM mein milegi!_")
                            success, info = await send_file_to_pm(client, message.from_user, pending_file_id, prem_user)
                            await wait.delete()
                            if not success:
                                await message.reply(f"❌ File nahi aayi: `{info}`")
                    else:
                        await message.reply("✅ **Verify Ho Gaya!** 🎉\n\nAb group mein search karo!")
                else:
                    next_label = next_sl.get("label", "Next Shortlink")
                    me2 = await client.get_me()
                    token2 = await make_token(uid, f"sv_{str(next_sl['_id'])}")
                    sl_id2 = str(next_sl["_id"])
                    verify_url2 = f"https://t.me/{me2.username}?start=sv_{uid}_{token2}_{sl_id2}"
                    short2 = await get_cached_shortlink(uid, 0, verify_url2, next_sl)
                    await message.reply(
                        f"✅ **{sl_label} Verified!**\n\n"
                        f"Ek aur baaki hai: **{next_label}**\n"
                        f"👇 Neeche link dabao:",
                        reply_markup=InlineKeyboardMarkup([
                            [InlineKeyboardButton(f"🔗 {next_label} Verify Karo", url=short2)],
                            [InlineKeyboardButton("❓ Verify Kaise Kare?", url=HOW_TO_VERIFY)],
                            [InlineKeyboardButton("💎 Premium lo — Sab Skip", callback_data="buy_premium")]
                        ])
                    )
        else:
            await message.reply(
                "❌ **Token expire ho gaya!**\n\n"
                "Group mein dobara search karo — naya link milega.\n"
                "💡 Tip: Link milte hi jaldi complete karo!"
            )
        return

    # ── gf_ — Group se PM redirect hua, ab file process karo ──
    if args.startswith("gf_"):
        # Format: gf_{msg_id}_{chat_id_for_sl}
        parts = args[3:].split("_", 1)
        if len(parts) != 2:
            await message.reply("❌ Invalid link."); return
        try:
            msg_id = int(parts[0])
            chat_id_for_sl = int(parts[1])
        except:
            await message.reply("❌ Invalid link."); return

        if await is_banned(uid):
            await message.reply("🚫 Aap banned hain!"); return

        s = await get_settings()
        prem = await is_premium(uid)
        me = await client.get_me()

        # ── Group Premium Check ──
        # Agar group ne premium liya hai: global shortlink/blogger/force_sub SKIP karo
        # Sirf group ka apna shortlink use hoga (agar set kiya ho)
        async def _is_grp_prem(cid):
            doc = await group_prem_col.find_one({"chat_id": cid, "status": "approved"})
            if not doc: return False
            exp = make_aware(doc.get("expiry"))
            if exp and now() > exp:
                await group_prem_col.update_one({"chat_id": cid}, {"$set": {"status": "expired"}})
                return False
            return True

        grp_has_prem = await _is_grp_prem(chat_id_for_sl) if chat_id_for_sl else False

        # STEP 1: Ad Verify ya Shortlink Verify
        if not prem:
            # ── AD SYSTEM ──
            if AD_SYSTEM_ENABLED and KOYEB_URL:
                ad_verified = await is_ad_verified(uid)  # ✅ FIX: 3-ghante interval
                if not ad_verified:
                    ad = await ad_get_next(uid)
                    if not ad:
                        # Koi active ad nahi — admin ko remind karo, user ko seedha file do
                        logger.warning(f"AD_SYSTEM ON but no active ad for uid={uid}. File diya bina verify ke.")
                        # Seedha file flow continue karega (fall through)
                        pass
                    if ad:
                        from urllib.parse import quote as _qp
                        token = await make_token(uid, "av")
                        # ✅ Generate shortlink if ad has shortlink enabled
                        _sl_url = ""
                        if ad.get("shortlink_enabled") and ad.get("shortlink_url") and ad.get("shortlink_api"):
                            # ✅ FIX: Shortlink target = ad URL (user lands on ad after shortlink, then comes back)
                            _verify_url = ad.get("ad_url") or f"{KOYEB_URL}/"
                            _sl_url = await _generate_ad_shortlink(ad["shortlink_url"], ad["shortlink_api"], _verify_url)
                        ad_page_url = (
                            f"{KOYEB_URL}/?uid={uid}"
                            f"&avt={token}"
                            f"&adu={_qp(ad.get('ad_url',''), safe='')}"
                            f"&adl={_qp(ad.get('title',''), safe='')}"
                            f"&add={_qp(ad.get('description',''), safe='')}"
                            f"&adbn={_qp(ad.get('button_name','Visit'), safe='')}"
                            f"&adimg={_qp(ad.get('image_url',''), safe='')}"
                            f"&adsl={_qp(_sl_url, safe='')}"
                            f"&howto={_qp(ad.get('how_to_verify_url',''), safe='')}"
                            f"&adtype={ad.get('ad_type','image')}"
                            f"&advid={_qp(ad.get('video_url',''), safe='')}"
                            f"&t1={ad.get('timer1',60)}&t2={ad.get('timer2',30)}"
                        )
                        await users_col.update_one(
                            {"user_id": uid},
                            {"$set": {"pending_file_id": msg_id, "pending_file_chat": chat_id_for_sl}},
                            upsert=True
                        )
                        await message.reply(
                            "🎬 **File Unlock Karo — 1 Step Only!**\n\n"
                            "📢 Ek sponsor ka page explore karo aur **free mein** apni file lo! ✅\n\n"
                            "💎 Premium users ko yeh step nahi karna!",
                            reply_markup=InlineKeyboardMarkup([[
                                InlineKeyboardButton("🔓 Unlock Karo — Ad Dekho", web_app=WebAppInfo(url=ad_page_url))
                            ],[
                                InlineKeyboardButton("❓ Verify Kaise Kare?", url="https://t.me/asbhai_bsr/667")
                            ],[
                                InlineKeyboardButton("💎 Premium lo — Ads Skip Karo!", callback_data="show_premium")
                            ]])
                        )
                        return
            # ── SHORTLINK SYSTEM (fallback) ──
            elif not AD_SYSTEM_ENABLED:
                async def _grp_sl_gf(cid):
                    sls = []
                    async for doc in group_sl_col.find({"chat_id": cid, "active": True}).sort("order", 1):
                        sls.append(doc)
                    return sls

                # ── SHORTLINK VERIFY (blogger system removed) ──
                grp_sl_list = await _grp_sl_gf(chat_id_for_sl) if chat_id_for_sl else []
                needs_verify = False
                short = None; sl_label = "Verify"; hours = 24

                if grp_has_prem and not grp_sl_list:
                    needs_verify = False
                elif grp_sl_list:
                    sl = grp_sl_list[0]
                    sl_id = str(sl["_id"]); hours = sl.get("hours", 24)
                    log_doc = await verify_log_col.find_one(
                        {"user_id": uid, "shortlink_id": sl_id}, sort=[("verified_at", -1)]
                    )
                    if not log_doc or now() - make_aware(log_doc.get("verified_at")) >= timedelta(hours=hours):
                        needs_verify = True
                    if needs_verify:
                        token = await make_token(uid, f"sv_{sl_id}")
                        verify_url = f"https://t.me/{me.username}?start=sv_{uid}_{token}_{sl_id}"
                        short = await get_cached_shortlink(uid, chat_id_for_sl, verify_url, sl)
                        sl_label = sl.get("label", "Verify")
                elif not grp_has_prem:
                    all_done, next_sl, _ = await get_user_verify_state(uid)
                    if not all_done and s.get("shortlink_enabled", True):
                        needs_verify = True
                        if next_sl:
                            sl_id = str(next_sl["_id"]); sl_label = next_sl.get("label", "Verify"); hours = next_sl.get("hours", 24)
                            token = await make_token(uid, f"sv_{sl_id}")
                            verify_url = f"https://t.me/{me.username}?start=sv_{uid}_{token}_{sl_id}"
                            short = await get_cached_shortlink(uid, chat_id_for_sl, verify_url, next_sl)
                        elif SHORTLINK_API:
                            token = await make_token(uid, "sv_env")
                            verify_url = f"https://t.me/{me.username}?start=sv_{uid}_{token}"
                            try:
                                api_url = f"https://{SHORTLINK_URL}/api?api={SHORTLINK_API}&url={verify_url}&format=text"
                                async with aiohttp.ClientSession() as sess:
                                    async with sess.get(api_url, timeout=aiohttp.ClientTimeout(total=10)) as r:
                                        res_text = (await r.text()).strip()
                                        short = res_text if res_text.startswith("http") else verify_url
                            except: short = verify_url
                        else:
                            needs_verify = False

                if needs_verify and short:
                    await users_col.update_one(
                        {"user_id": uid},
                        {"$set": {"pending_file_id": msg_id, "pending_file_chat": chat_id_for_sl}},
                        upsert=True
                    )
                    await message.reply(
                        f"🔐 **File ke liye ek step baaki hai!**\n\n"
                        f"**Kaise kare:**\n"
                        f"1️⃣ Neeche **LINK** button dabao\n"
                        f"2️⃣ Page pe steps complete karo\n"
                        f"3️⃣ Wapas aao — file milegi! ✅\n\n"
                        f"💡 _Link kaam na kare to copy karo aur Chrome mein paste karo_\n"
                        f"⏰ Har **{hours} ghante** mein ek baar\n"
                        f"💎 Premium lo — **kabhi verify na karo!**",
                        reply_markup=InlineKeyboardMarkup([
                            [InlineKeyboardButton(f"🔗 {sl_label} — Verify Karo", url=short)],
                            [InlineKeyboardButton("❓ Verify Kaise Kare?", url=HOW_TO_VERIFY)],
                            [InlineKeyboardButton("💎 Premium lo — No Verify!", callback_data="show_premium")],
                        ])
                    )
                    return

        # STEP 2: Force Sub (group premium groups mein skip)
        if not prem and not grp_has_prem:
            joined, not_joined = await check_member_multi(uid, prem)
            if not joined:
                kb = await build_fsub_keyboard(not_joined, uid)
                names = ", ".join(ch.get("title", "Channel") for ch in not_joined)
                await message.reply(
                    f"📢 **Pehle Join Karo!**\n\n**{names}** join karo — phir file milegi! ✅",
                    reply_markup=kb
                )
                return

        # STEP 3: Daily Limit
        if not prem:
            count = await get_daily_count(uid)
            if count >= s.get("daily_limit", 10):
                await message.reply(
                    f"⚠️ **Daily Limit Khatam!**\n💎 /premium lo unlimited ke liye!"
                )
                return

        # STEP 4: File Send
        wait = await message.reply("⚡ File prepare ho rahi hai... ⏳\n_Thodi der mein PM mein milegi!_")
        success, info = await send_file_to_pm(client, message.from_user, msg_id, prem)
        await wait.delete()
        if not success:
            await message.reply(f"❌ File nahi aayi.\n`{info}`")
        return

    # ── getfile_ — miniapp ad verify ke baad bot pe wapas aata hai ──
    if args.startswith("getfile_"):
        token_or_uid = args[8:]
        
        # Format A: getfile_TOKEN (miniapp redirect — naya system)
        # Format B: getfile_uid_msgid (legacy deep link)
        parts = token_or_uid.split("_", 1)
        
        # Check if it's a token (alphanumeric, length 20) or uid_msgid
        is_token_format = len(parts) == 1 or not parts[0].isdigit()
        
        if is_token_format:
            # ── Format A: getfile_TOKEN ──
            # Miniapp mein ads dekhe → bot pe wapas aaya → pending file bhejo
            token = token_or_uid
            valid, token_uid = await check_token(token)
            if not valid or token_uid != uid:
                await message.reply(
                    "❌ **Invalid ya Expired Link!**\n\n"
                    "Miniapp se dobara try karo ya group mein file button dabao."
                )
                return
            
            if await is_banned(uid):
                await message.reply("🚫 Aap banned hain!")
                return
            
            # Mark ad as verified
            await mark_ad_verified(uid)
            
            # Pending file fetch karo
            user_doc = await users_col.find_one({"user_id": uid})
            pending_id = user_doc.get("pending_file_id") if user_doc else None
            pending_chat = user_doc.get("pending_file_chat", 0) if user_doc else 0
            
            if not pending_id:
                await message.reply(
                    "✅ **Ad Verify Ho Gaya!**\n\n"
                    "Ab wapas group mein jao aur file button dobara dabao — "
                    "ab seedha milegi! 🎬"
                )
                return
            
            prem = await is_premium(uid)
            s = await get_settings()
            
            # Daily limit check (premium skip)
            if not prem:
                count = await get_daily_count(uid)
                if count >= s.get("daily_limit", 10):
                    await message.reply(
                        f"⚠️ **Daily Limit Khatam!**\n"
                        f"💎 /premium lo unlimited ke liye!"
                    )
                    return
            
            # File bhejo
            wait = await message.reply("⚡ **File aa rahi hai...** ⏳")
            success, info = await send_file_to_pm(client, message.from_user, int(pending_id), prem)
            await wait.delete()
            
            # Clear pending
            await users_col.update_one(
                {"user_id": uid},
                {"$unset": {"pending_file_id": "", "pending_file_chat": ""}}
            )
            
            if not success:
                await message.reply(f"❌ File nahi aayi.\n`{info}`")

            return
        
        # ── Format B: getfile_uid_msgid (legacy) ──
        if len(parts) != 2:
            await message.reply("❌ Invalid link.")
            return
        try:
            req_uid = int(parts[0])
            msg_id = int(parts[1])
        except:
            await message.reply("❌ Invalid link.")
            return
        if uid != req_uid:
            await message.reply("❌ Yeh file aapke liye nahi! Apna search karo.")
            return

        if await is_banned(uid):
            await message.reply("🚫 Aap banned hain!")
            return

        s = await get_settings()
        prem = await is_premium(uid)

        # STEP 1: Ad Verify ya Shortlink Verify
        if not prem:
            if AD_SYSTEM_ENABLED and KOYEB_URL:
                ad_verified = await is_ad_verified(uid)  # ✅ FIX: 3-ghante interval
                if not ad_verified:
                    ad = await ad_get_next(uid)
                    if not ad:
                        # Koi active ad nahi — admin ko remind karo, user ko seedha file do
                        logger.warning(f"AD_SYSTEM ON but no active ad for uid={uid}. File diya bina verify ke.")
                        # Seedha file flow continue karega (fall through)
                        pass
                    if ad:
                        from urllib.parse import quote as _qp
                        token = await make_token(uid, "av")
                        # ✅ Generate shortlink if ad has shortlink enabled
                        _sl_url = ""
                        if ad.get("shortlink_enabled") and ad.get("shortlink_url") and ad.get("shortlink_api"):
                            # ✅ FIX: Shortlink target = ad URL (user lands on ad after shortlink, then comes back)
                            _verify_url = ad.get("ad_url") or f"{KOYEB_URL}/"
                            _sl_url = await _generate_ad_shortlink(ad["shortlink_url"], ad["shortlink_api"], _verify_url)
                        ad_page_url = (
                            f"{KOYEB_URL}/?uid={uid}"
                            f"&avt={token}"
                            f"&adu={_qp(ad.get('ad_url',''), safe='')}"
                            f"&adl={_qp(ad.get('title',''), safe='')}"
                            f"&add={_qp(ad.get('description',''), safe='')}"
                            f"&adbn={_qp(ad.get('button_name','Visit'), safe='')}"
                            f"&adimg={_qp(ad.get('image_url',''), safe='')}"
                            f"&adsl={_qp(_sl_url, safe='')}"
                            f"&howto={_qp(ad.get('how_to_verify_url',''), safe='')}"
                            f"&adtype={ad.get('ad_type','image')}"
                            f"&advid={_qp(ad.get('video_url',''), safe='')}"
                            f"&t1={ad.get('timer1',60)}&t2={ad.get('timer2',30)}"
                        )
                        await users_col.update_one(
                            {"user_id": uid},
                            {"$set": {"pending_file_id": msg_id, "pending_file_chat": 0}},
                            upsert=True
                        )
                        await message.reply(
                            "🎬 **File Unlock Karo — 1 Step Only!**\n\n"
                            "📢 Ek sponsor ka page explore karo aur **free mein** apni file lo! ✅\n\n"
                            "💎 Premium users ko yeh step nahi karna!",
                            reply_markup=InlineKeyboardMarkup([[
                                InlineKeyboardButton("🔓 Unlock Karo — Ad Dekho", web_app=WebAppInfo(url=ad_page_url))
                            ],[
                                InlineKeyboardButton("❓ Verify Kaise Kare?", url="https://t.me/asbhai_bsr/667")
                            ],[
                                InlineKeyboardButton("💎 Premium lo — Ads Skip Karo!", callback_data="show_premium")
                            ]])
                        )
                        return
            elif not AD_SYSTEM_ENABLED and s.get("shortlink_enabled", True):
                all_done, next_sl, _ = await get_user_verify_state(uid)
                if not all_done:
                    me_obj = await client.get_me()
                    short = None; sl_label = "Verify"; hours = 24
                    if next_sl:
                        sl_id = str(next_sl["_id"])
                        sl_label = next_sl.get("label", "Verify")
                        hours = next_sl.get("hours", 24)
                        token = await make_token(uid, f"sv_{sl_id}")
                        verify_url = f"https://t.me/{me_obj.username}?start=sv_{uid}_{token}_{sl_id}"
                        short = await get_cached_shortlink(uid, 0, verify_url, next_sl)
                    elif SHORTLINK_API:
                        token = await make_token(uid, "sv_env")
                        verify_url = f"https://t.me/{me_obj.username}?start=sv_{uid}_{token}"
                        try:
                            api_url = f"https://{SHORTLINK_URL}/api?api={SHORTLINK_API}&url={verify_url}&format=text"
                            async with aiohttp.ClientSession() as sess:
                                async with sess.get(api_url, timeout=aiohttp.ClientTimeout(total=10)) as r:
                                    result = (await r.text()).strip()
                                    short = result if result.startswith("http") else verify_url
                        except:
                            short = verify_url
                    else:
                        all_done = True

                    if not all_done and short:
                        await users_col.update_one(
                            {"user_id": uid},
                            {"$set": {"pending_file_id": msg_id, "pending_file_chat": 0}},
                            upsert=True
                        )
                        await message.reply(
                            f"🔐 **File Lene Se Pehle Ek Step!**\n\n"
                            f"**Steps follow karo:**\n"
                            f"1️⃣ Neeche **LINK** button dabao\n"
                            f"2️⃣ Page pe steps complete karo\n"
                            f"3️⃣ Bot pe wapas aao — file seedha milegi! 🎉\n\n"
                            f"⏰ Har **{hours} ghante** mein ek baar\n"
                            f"💎 Premium = kabhi verify nahi!",
                            reply_markup=InlineKeyboardMarkup([
                                [InlineKeyboardButton(f"🔗 {sl_label} — Verify Karo", url=short)],
                                [InlineKeyboardButton("❓ Verify Kaise Kare?", url=HOW_TO_VERIFY)],
                                [InlineKeyboardButton("💎 Premium lo — No Verify!", callback_data="show_premium")],
                            ])
                        )
                        return

        # STEP 2: Force Sub
        if not prem:
            joined, not_joined = await check_member_multi(uid, prem)
            if not joined:
                kb = await build_fsub_keyboard(not_joined, uid)
                names = ", ".join(ch.get("title", "Channel") for ch in not_joined)
                await message.reply(
                    f"📢 **Pehle Join Karo!**\n\n**{names}** join karo — phir file milegi! ✅",
                    reply_markup=kb
                )
                return

        # STEP 3: Daily limit
        if not prem:
            count = await get_daily_count(uid)
            if count >= s.get("daily_limit", 10):
                await message.reply(
                    f"⚠️ **Daily Limit Khatam!**\n💎 /premium lo unlimited ke liye!"
                )
                return

        # STEP 4: Send file
        wait = await message.reply("⚡ File prepare ho rahi hai... ⏳\n_Thodi der mein PM mein milegi!_")
        success, info = await send_file_to_pm(client, message.from_user, msg_id, prem)
        await wait.delete()
        if not success:
            await message.reply(f"❌ File nahi aa payi.\nError: `{info}`")
        return

    # ── Normal /start ──
    me = await client.get_me()
    miniapp_url = _miniapp_url(uid, getattr(message.from_user,'first_name',None) or 'User')

    buttons = [
        [
            InlineKeyboardButton("📢 Channel", url=f"https://t.me/{FORCE_SUB_CHANNEL.replace('@','')}"),
            InlineKeyboardButton("➕ Group Add", url=f"https://t.me/{me.username}?startgroup=true")
        ],
        [
            InlineKeyboardButton("💎 Premium", callback_data="show_premium"),
            InlineKeyboardButton("ℹ️ Help", callback_data="help")
        ],
        [
            InlineKeyboardButton("📊 My Stats", callback_data="my_stats"),
            InlineKeyboardButton("🔗 Refer & Earn", callback_data="refer_info")
        ],
        [
            InlineKeyboardButton("🆘 Support", url=SUPPORT_LINK)
        ]
    ]
    if miniapp_url:
        buttons.append([InlineKeyboardButton("🌐 Mini App Kholo", web_app=WebAppInfo(url=miniapp_url))])

    # Funny/Roast personality greetings
    greetings = [
        f"🔥 **AsBhai Drop Bot** 🔥\n\n"
        f"Arre **{message.from_user.mention}**! Kya haal hai boss? 😎\n\n"
        f"Main hoon tera file wala dost — jo bhi chahiye, bas naam bol! 🎬\n\n"
        f"**Kaise kaam karta hai (ekdum easy):**\n"
        f"1️⃣ Group mein file naam likh — seedha results aayenge! 🔍\n"
        f"2️⃣ File ke button par click karo 📥\n"
        f"3️⃣ Ek baar verify karo → file PM mein! ✨\n\n"
        f"💎 **Premium** = Verify skip + 10 results + HD Stream + Download! 🏆\n"
        f"🔗 **10 Refer** = 15 din FREE Premium! 🎁\n\n"
        f"Chal shuru karte hai — `/premium` | `/mystats` | `/referlink`",

        f"💫 **AsBhai Drop Bot** 💫\n\n"
        f"Swagat hai **{message.from_user.mention}**! 🙏\n\n"
        f"Kya dekhna hai aaj? Movie? Series? Anime? Sab milega! 🎬🍿\n\n"
        f"**Simple steps:**\n"
        f"1️⃣ 🔍 Group mein type karo jo chahiye\n"
        f"2️⃣ 📥 Results turant aayenge — button dabao\n"
        f"3️⃣ 🔗 Ek baar verify karo (shortlink) → file milegi!\n"
        f"4️⃣ 📢 Channel join hai to seedha file PM mein!\n\n"
        f"💎 **Premium = Boss Mode** — No verify, HD Stream, Unlimited! 🤑\n"
        f"🔗 Dosto ko bulao — **10 refer = 15 din FREE premium!**\n\n"
        f"Commands: `/premium` | `/mystats` | `/referlink`",

        f"⚡ **AsBhai Drop Bot** ⚡\n\n"
        f"Kya bolti public! **{message.from_user.mention}** aa gaya scene mein! 🎉\n\n"
        f"Mujhse koi file maang — main refuse nahi karta! 😏\n\n"
        f"**Instructions (padh le zara):**\n"
        f"1️⃣ Group mein movie/show ka naam likh ✍️\n"
        f"2️⃣ Results turant dikhenge — koi wait nahi! ⚡\n"
        f"3️⃣ File button dabao → verify karo (2 sec) → file! 📥\n"
        f"4️⃣ PM check kar — file ready! 🎬\n\n"
        f"💎 **Premium loge to life set!** Stream + Download + No verify! 🔥\n"
        f"🔗 **10 Refer karke FREE premium le lo!** 🎁\n\n"
        f"`/premium` | `/mystats` | `/referlink`",
    ]
    await message.reply(
        random.choice(greetings),
        reply_markup=InlineKeyboardMarkup(buttons)
    )

# ═══════════════════════════════════════
#  HELPER: Build result buttons with filter row
# ═══════════════════════════════════════
def _build_result_buttons(found_page, uid, bot_username, qkey, page=0, total_pages=1):
    """Unified button builder for search results - verify/fsub on click"""
    btns = []
    for idx, fmsg in enumerate(found_page):
        fname = get_file_name(fmsg)
        fname_clean = re.sub(r'[@#]\w+', '', re.sub(r'_+', ' ', fname)).strip()
        fname_show = fname_clean[:36] if fname_clean else f"File {page*5+idx+1}"
        fsize = get_file_size(fmsg)
        sz = f" [{fsize}]" if fsize else ""
        # ══ NEW: callback_data instead of URL — verify/fsub tab hoga jab click ho ══
        # Format: getf_{uid}_{msg_id}
        btns.append([InlineKeyboardButton(f"📥 {fname_show}{sz}", callback_data=f"getf_{uid}_{fmsg.id}")])

    # Pagination
    if total_pages > 1:
        nav = []
        if page > 0:
            nav.append(InlineKeyboardButton("◀️ Prev", callback_data=f"rpage_{uid}_{qkey}_{page-1}"))
        nav.append(InlineKeyboardButton(f"{page+1}/{total_pages}", callback_data="noop"))
        if page < total_pages - 1:
            nav.append(InlineKeyboardButton("▶️ Next", callback_data=f"rpage_{uid}_{qkey}_{page+1}"))
        btns.append(nav)

    # Filter buttons
    btns.append([
        InlineKeyboardButton("🌐 Language", callback_data=f"flang_{uid}_{qkey}"),
        InlineKeyboardButton("📺 Season",   callback_data=f"fseason_{uid}_{qkey}"),
    ])
    btns.append([
        InlineKeyboardButton("🎬 Episode",  callback_data=f"fepisode_{uid}_{qkey}"),
        InlineKeyboardButton("🔙 Back",     callback_data=f"fback_{uid}_{qkey}"),
    ])
    btns.append([
        InlineKeyboardButton("📤 Send All", callback_data=f"fsendall_{uid}_{qkey}"),
    ])
    return btns

# ═══════════════════════════════════════
#  LINK PROTECTION — called from search_handler
# ═══════════════════════════════════════
async def link_protection_handler(client, message: Message):
    """Detect links in group and warn/mute/ban — called internally from search_handler"""
    if not message.from_user: return
    uid = message.from_user.id
    chat_id = message.chat.id

    # Skip admins
    if uid in ADMINS: return
    try:
        member = await client.get_chat_member(chat_id, uid)
        if member.status in [enums.ChatMemberStatus.OWNER, enums.ChatMemberStatus.ADMINISTRATOR]:
            return
    except: return

    # Check group settings
    gs = await get_group_settings(chat_id)
    if not gs.get("link_protection", True): return

    text = message.text or message.caption or ""
    if not await check_link_in_message(text): return

    # Link found! Delete message
    try:
        await message.delete()
    except: pass

    warn_limit = gs.get("link_warn_limit", 3)
    action = gs.get("link_action", "warn")
    warn_count = await add_user_warn(chat_id, uid)

    # Log
    await send_log(
        f"🔗 #LinkDetected\n\n"
        f"👤 {message.from_user.mention} (`{uid}`)\n"
        f"🏘 {message.chat.title} (`{chat_id}`)\n"
        f"⚠️ Warning: {warn_count}/{warn_limit}\n"
        f"📝 Text: `{text[:100]}`\n"
        f"🕐 {now_ist().strftime('%d %b %H:%M')} IST"
    )

    if warn_count >= warn_limit:
        if action == "ban":
            try:
                await client.ban_chat_member(chat_id, uid)
                msg = await message.reply(
                    f"🚫 **{message.from_user.mention} BANNED!**\n\n"
                    f"Reason: {warn_count} baar link bheja.\n"
                    f"Links bhejne ki permission nahi hai!"
                )
            except Exception as e:
                msg = await message.reply(f"⚠️ Ban nahi kar paya: {e}")
        elif action == "mute":
            try:
                await client.restrict_chat_member(
                    chat_id, uid,
                    ChatPermissions(can_send_messages=False),
                    until_date=datetime.now() + timedelta(hours=24)
                )
                msg = await message.reply(
                    f"🔇 **{message.from_user.mention} MUTED (24 hrs)!**\n\n"
                    f"Reason: {warn_count} baar link bheja."
                )
            except Exception as e:
                msg = await message.reply(f"⚠️ Mute nahi kar paya: {e}")
        else:
            msg = await message.reply(
                f"🚫 **{message.from_user.mention} — Last Warning!**\n\n"
                f"⚠️ {warn_count}/{warn_limit} warnings ho gayi!\n"
                f"Ek aur link = **Ban/Mute**!"
            )
        await reset_user_warns(chat_id, uid)
    else:
        msg = await message.reply(
            f"⚠️ **{message.from_user.mention}** — Link mat bhejo!\n\n"
            f"Warning: **{warn_count}/{warn_limit}**\n"
            f"{'🔴' * warn_count}{'⚪' * (warn_limit - warn_count)}\n\n"
            f"Ek aur link = action liya jaayega!"
        )

    asyncio.create_task(del_later(msg, 60))

# ═══════════════════════════════════════
#  GROUP SEARCH — FIXED
# ═══════════════════════════════════════
@bot.on_message(
    filters.group & filters.text &
    ~filters.bot &
    ~filters.via_bot &
    filters.incoming &
    ~filters.command([
        "start","help","stats","broadcast","setdelete",
        "addpremium","removepremium","forcesub","settings",
        "premium","ping","shortlink","setlimit","setresults",
        "mystats","ban","unban","maintenance","request","referlink",
        "fsub","groupsettings","gsettings","gset",
        "addshortlink","removeshortlink","shortlinks","addblog","removeblog","blogposts","syncsheet","setcommands",
        "gshortlink","gshortlinkremove","gshortlinks","requests",
        "admin","gstats","linkprotect","notify","warn","resetwarn",
        "addforcechannel","removeforcechannel","resetsettings","id"
    ])
)
async def search_handler(client, message: Message):
    if not message.from_user: return
    if message.from_user.is_bot: return
    if message.forward_date: return
    if message.via_bot: return

    try:
        me = await client.get_me()
        if message.from_user.id == me.id: return
    except: pass

    query = (message.text or "").strip()
    if query.startswith("/"): return

    if message.entities:
        for ent in message.entities:
            if ent.type == enums.MessageEntityType.BOT_COMMAND: return

    # If it's a link — run link protection then stop search
    if await check_link_in_message(query):
        await link_protection_handler(client, message)
        return

    if len(query) < 2 or len(query) > 80: return

    import unicodedata
    plain = ''.join(c for c in query if unicodedata.category(c) not in ('So','Sm','Sk','Sc','Cs')).strip()
    if len(plain) < 2: return

    bot_msg_prefixes = (
        "🔍","😕","⚠","📩","🔐","╔","🔧","✅","❌","🗂","🆘",
        "🎉","💎","📢","⏳","🔒","🏓","📊","👤","🚫","🔗","📱",
        "ℹ️","💰","🆓","📥","🏘","⚙️","🔔","📋",
    )
    if any(query.startswith(p) for p in bot_msg_prefixes): return

    skip_words = {"hi","hello","hii","hlo","helo","ok","okay","thanks","ty",
                  "thx","bye","lol","haha","yes","no","kya","koi",
                  "hai","hain","nahi","kaise","kaisa","mera","tera",
                  "acha","accha","theek","thik","bhai","bhi","wala",
                  "movie","film","web","series","episode","part"}
    if query.lower() in skip_words: return

    uid = message.from_user.id
    cache_key = f"{uid}_{query.lower()[:20]}"
    if _search_cooldown.get(cache_key, 0) > asyncio.get_event_loop().time():
        return

    if _search_locks.get(uid):
        return
    _search_locks[uid] = True
    _search_cooldown[cache_key] = asyncio.get_event_loop().time() + 30

    try:
        await save_group(message.chat)
        await save_user(message.from_user)

        chat_id = message.chat.id
        s = await get_settings()
        gs = await get_group_settings(chat_id)

        if await is_banned(uid): return
        if s.get("maintenance") and uid not in ADMINS:
            msg = await message.reply("🔧 Maintenance. Thodi der baad try karo.")
            asyncio.create_task(del_later(msg, 60))
            return

        prem = await is_premium(uid)

        if gs.get("request_mode") and not prem and uid not in ADMINS:
            msg = await message.reply(
                f"📩 **Request Mode Active**\n\n"
                f"Search band hai. `/request {query}` karein.\n"
                f"💎 Premium se search bypass karo!"
            )
            asyncio.create_task(del_later(msg, 300))
            return

        # ══ NEW FLOW: Seedha search — verify/fsub file button click pe hoga ══
        # Force sub aur shortlink verify SEARCH pe nahi hoga
        # Ye sab tab hoga jab user file button click karega (getfile_ start param)

        if not prem:
            count = await get_daily_count(uid)
            if count >= s.get("daily_limit", 10):
                msg = await message.reply(
                    f"⚠️ {message.from_user.mention}, aaj ki limit "
                    f"**{s.get('daily_limit',10)}** ho gayi!\n"
                    f"💎 /premium lo unlimited ke liye!"
                )
                asyncio.create_task(del_later(msg, 300))
                return

        try:
            wait_msg = await message.reply(f"⏳ **Searching...** `{query}`\n🔍 _Database check ho rahi hai..._")
            if isinstance(wait_msg, (list, tuple)):
                wait_msg = wait_msg[0] if wait_msg else None
            if not wait_msg:
                _search_locks[uid] = False
                return
        except FloodWait as e:
            logger.warning(f"FloodWait sending wait_msg, skip uid={uid}")
            _search_locks[uid] = False
            return
        except Exception as e:
            logger.error(f"wait_msg error: {e}")
            _search_locks[uid] = False
            return

        if prem:
            limit = s.get("premium_results", gs.get("premium_results", 10))
        else:
            limit = s.get("free_results", gs.get("free_results", 5))

        found = await do_search(query, limit=limit)

        if not found:
            google_q = query.replace(" ", "+")
            filter_url = "https://t.me/asfilter_bot?start=" + query.replace(" ", "_")
            google_url = f"https://www.google.com/search?q={google_q}+full+movie"
            # Spelling fix suggestion
            fixed_query = _fix_query_spelling(query)
            spelling_note = ""
            if fixed_query.lower() != query.lower():
                spelling_note = f"\n\n💡 **Spelling fix try karo:** **{fixed_query}**"
            edited = await wait_msg.edit(
                f"❌ **'{query}' nahi mila!**\n\n"
                f"**Tips:**\n"
                f"• 🔤 Spelling check karo — ek galti = no result\n"
                f"• ✂️ Sirf naam likho — year/quality/language mat likho\n"
                f"• 🔁 Alag spelling try karo (e.g. `Bahubali` ya `Baahubali`)"
                f"{spelling_note}\n\n"
                f"👇 Ya yahan dhundho:",
                reply_markup=InlineKeyboardMarkup([[
                    InlineKeyboardButton("🔍 @asfilter_bot mein dhundho", url=filter_url),
                ],[
                    InlineKeyboardButton("🌍 Google mein dhundho", url=google_url),
                ]])
            )
            asyncio.create_task(del_later(edited, 300))
            return

        found = found[:limit]
        await wait_msg.delete()
        me = await client.get_me()

        # ✅ FIX: page_size = 5 (ek page pe 5 results) — total limit se alag
        # Agar 10 results hain to 2 pages banenge (5+5), Prev/Next buttons aayenge
        PAGE_SIZE = 5
        total_pages = max(1, (len(found) + PAGE_SIZE - 1) // PAGE_SIZE)
        page_found = found[:PAGE_SIZE]

        qkey = re.sub(r'[^a-zA-Z0-9_]', '_', query)[:18]
        _result_cache[f"{uid}_{qkey}"] = found

        file_buttons = _build_result_buttons(page_found, uid, me.username, qkey, 0, total_pages)
        kb = InlineKeyboardMarkup(file_buttons)
        t = gs.get("auto_delete_time", 300)
        mins = t // 60
        count_text = len(found)
        page_info = f" • Page 1/{total_pages}" if total_pages > 1 else ""

        # ── TMDb Movie Info fetch (settings se ON/OFF) ──
        tmdb_info = None
        if s.get("tmdb_enabled", True):
            try:
                async with aiohttp.ClientSession() as tmdb_sess:
                    tmdb_info = await tmdb_search(query, tmdb_sess)
            except Exception as _te:
                logger.warning(f"TMDb fetch error: {_te}")

        # ── Build result message with TMDb info ──
        if tmdb_info:
            title_line = f"🎬 **{tmdb_info['title']}**"
            if tmdb_info.get('year'):
                title_line += f" ({tmdb_info['year']})"
            type_line = tmdb_info.get('type', '')
            rating_line = ""
            if tmdb_info.get('rating'):
                stars = tmdb_info.get('stars', '')
                rating_line = f"⭐ IMDB: **{tmdb_info['rating']}/10** {stars}"
                if tmdb_info.get('imdb_url'):
                    rating_line += f"  [→ IMDB]({tmdb_info['imdb_url']})"
            overview_line = f"📝 _{tmdb_info['overview']}_" if tmdb_info.get('overview') else ""

            result_text = (
                f"{title_line}  {type_line}\n"
                f"{rating_line}\n"
                f"{overview_line}\n\n"
                f"📂 **{count_text} file{'s' if count_text > 1 else ''} mili!**"
                + (f"  _(Page 1/{total_pages})_" if total_pages > 1 else "") + "\n"
                f"👇 Button dabao — file seedha PM mein aayegi! 📥\n"
                f"⏳ _{mins} min baad message delete ho jaayega — save kar lo!_"
            )
            # Send poster + results
            if tmdb_info.get('poster_url'):
                try:
                    result_msg = await message.reply_photo(
                        photo=tmdb_info['poster_url'],
                        caption=result_text,
                        reply_markup=kb
                    )
                except Exception:
                    result_msg = await message.reply(result_text, reply_markup=kb, disable_web_page_preview=True)
            else:
                result_msg = await message.reply(result_text, reply_markup=kb, disable_web_page_preview=True)
        else:
            # Fallback — funny messages (TMDb nahi mila)
            p_emoji = random.choice(["🌍","🌎","🌏","🪐","🌕","⭐","🌟","💫","✨","🔥","💥","⚡"])
            page_nav_hint = f"\n📄 _Page 1/{total_pages} — Next ke liye neeche ▶️ button dabao_" if total_pages > 1 else ""
            result_msgs = [
                f"{p_emoji} **{message.from_user.mention}**, mil gaya! 😎\n\n"
                f"📂 **{count_text} file{'s' if count_text > 1 else ''} mili!**{page_nav_hint}\n\n"
                f"👇 Button dabao — file PM mein seedha delivery! 📥\n"
                f"⏳ _{mins} min baad gayab — jaldi save karo!_ 🏃‍♂️",

                f"{p_emoji} Arre **{message.from_user.mention}**! Maal hazir hai bhai! 🎬\n\n"
                f"📂 **{count_text} result{'s' if count_text > 1 else ''} ready!**{page_nav_hint}\n\n"
                f"👇 Jis file chahiye — button dabao, file PM mein!\n"
                f"⏳ _{mins} min hai — save karo! ⏰_",

                f"💥 **{message.from_user.mention}**, dhundh liya! 🔍\n\n"
                f"📂 **{count_text} file{'s' if count_text > 1 else ''} tere liye!**{page_nav_hint}\n\n"
                f"👇 Button dabao = PM mein delivery! 📦\n"
                f"⏳ _{mins} min mein delete — jaldi! 😂_",

                f"🤖 **{message.from_user.mention}**, maang tha — de diya! 😎\n\n"
                f"📂 **{count_text} file{'s' if count_text > 1 else ''} hazir!**{page_nav_hint}\n\n"
                f"👇 Button dabao — seedha PM mein pakad!\n"
                f"⏳ _{mins} min baad gayab! 👻_",
            ]
            result_text = random.choice(result_msgs)
            if not prem:
                result_text += f"\n\n💎 _Premium lo = {s.get('premium_results', 10)} results + No verify + Stream!_"
            result_msg = await message.reply(result_text, reply_markup=kb)

        # Search log removed

        if gs.get("auto_delete", True):
            asyncio.create_task(del_later(result_msg, t))

    except FloodWait as e:
        logger.warning(f"FloodWait {e.value}s uid={uid}")
        await asyncio.sleep(min(e.value, 10))
    except Exception as e:
        logger.error(f"search_handler error uid={uid}: {e}")
    finally:
        _search_locks[uid] = False

# ═══════════════════════════════════════
#  REFER COMMAND
# ═══════════════════════════════════════
@bot.on_message(filters.command("referlink"))
async def refer_link_cmd(client, message: Message):
    uid = message.from_user.id
    me = await client.get_me()
    ref_link = f"https://t.me/{me.username}?start=ref_{uid}"
    doc = await users_col.find_one({"user_id": uid})
    refer_count = doc.get("refer_count", 0) if doc else 0
    needed = 10 - (refer_count % 10) if refer_count % 10 != 0 else 10
    await message.reply(
        f"🔗 **Aapka Refer Link**\n\n"
        f"`{ref_link}`\n\n"
        f"📊 Refers: {refer_count}\n"
        f"🎯 Premium ke liye: **{needed}** aur chahiye\n\n"
        f"**Reward:** Har 10 refer = **15 din FREE Premium** 💎",
        reply_markup=InlineKeyboardMarkup([
            [InlineKeyboardButton("📤 Share Karo", url=f"https://t.me/share/url?url={ref_link}&text=Is+bot+se+movies+free+mein+download+karo!")]
        ])
    )

# ═══════════════════════════════════════
#  PM SEARCH — Premium Only
# ═══════════════════════════════════════
@bot.on_message(
    filters.private & filters.text &
    filters.incoming &
    ~filters.bot &
    ~filters.command([
        "start","help","stats","broadcast","setdelete",
        "addpremium","removepremium","forcesub","settings",
        "premium","ping","shortlink","setlimit","setresults",
        "mystats","ban","unban","maintenance","request","referlink",
        "fsub","groupsettings","gsettings","gset",
        "addshortlink","removeshortlink","shortlinks","setcommands",
        "gshortlink","gshortlinkremove","gshortlinks","requests",
        "admin","gstats","linkprotect","notify","warn","resetwarn",
        "addforcechannel","removeforcechannel","resetsettings",
        "id","myid","admanager","adstatus","broadcast",
        "addblog","removeblog","blogposts","syncsheet"
    ])
)
async def pm_search_handler(client, message: Message):
    if not message.from_user: return
    if message.from_user.is_bot: return
    if message.forward_date: return
    uid = message.from_user.id
    await save_user(message.from_user)
    query_text = message.text.strip()
    if query_text.startswith("/"): return  # Command hai — search mein mat jaao
    if len(query_text) < 2: return

    prem = await is_premium(uid)
    if not prem and uid not in ADMINS:
        miniapp_url = _miniapp_url(uid, getattr(message.from_user,'first_name',None) or 'User')
        btns = []
        if miniapp_url:
            btns.append([InlineKeyboardButton("💎 Premium Lo — PM Search Enable", web_app=WebAppInfo(url=miniapp_url))])
        await message.reply(
            f"❌ PM mein search Premium users ke liye hai!\n\n"
            f"Group mein search karo ya Premium lo:",
            reply_markup=InlineKeyboardMarkup(btns) if btns else None
        )
        return

    if await is_banned(uid): return
    s = await get_settings()
    if s.get("maintenance") and uid not in ADMINS:
        await message.reply("🔧 Maintenance chal raha hai."); return

    wait_msg = await message.reply(f"⏳ **Searching...** `{query_text}`\n🔍 _Database check ho rahi hai..._")
    doc = await users_col.find_one({"user_id": uid})
    limit = doc.get("prem_results_pref", 10) if doc else 10
    found = await do_search(query_text, limit=limit)

    if not found:
        await wait_msg.edit(
            f"😕 '{query_text}' nahi mila\n\nSpelling check karo, dobara try karo.",
        )
        return

    await wait_msg.delete()
    me = await client.get_me()
    qkey = re.sub(r'[^a-zA-Z0-9_]', '_', query_text)[:18]
    _result_cache[f"{uid}_{qkey}"] = found
    btns = _build_result_buttons(found[:5], uid, me.username, qkey)

    roast_results = [
        f"🔍 **{len(found)} file mili!** Bot ne dhoondh liya! 😎\n\n👇 Button daba — PM mein file aayegi!",
        f"💥 **{len(found)} result{'s' if len(found) > 1 else ''}!** Le bhai, jhand maar di! 😂\n\n👇 Neeche se apni file pakad!",
        f"🎯 **{len(found)} file hazir!** Maang tha — de diya! 🤖\n\n👇 Button daba = PM delivery!",
        f"🗂 **{len(found)} result{'s' if len(found) > 1 else ''}** mila bhai!\n\n👇 File chahiye toh button daba!",
    ]
    result_msg = await message.reply(
        random.choice(roast_results),
        reply_markup=InlineKeyboardMarkup(btns)
    )
    s = await get_settings()
    if s.get("auto_delete"):
        asyncio.create_task(del_later(result_msg, s.get("auto_delete_time", 300)))

# ═══════════════════════════════════════
#  LINK PROTECTION COMMAND — NEW
# ═══════════════════════════════════════
@bot.on_message(filters.command("linkprotect"))
async def link_protect_cmd(client, message: Message):
    uid = message.from_user.id
    if message.chat.type == enums.ChatType.PRIVATE:
        await message.reply("❌ Ye command group mein use karo!")
        return

    chat_id = message.chat.id
    try:
        member = await client.get_chat_member(chat_id, uid)
        is_admin = member.status in [enums.ChatMemberStatus.OWNER, enums.ChatMemberStatus.ADMINISTRATOR] or uid in ADMINS
    except:
        is_admin = uid in ADMINS
    if not is_admin:
        await message.reply("❌ Sirf admins use kar sakte hain!"); return

    args = message.command
    gs = await get_group_settings(chat_id)

    if len(args) == 1:
        await message.reply(
            f"🛡 **Link Protection**\n\n"
            f"Status: **{'ON ✅' if gs.get('link_protection') else 'OFF ❌'}**\n"
            f"Warn Limit: **{gs.get('link_warn_limit', 3)}**\n"
            f"Action: **{gs.get('link_action', 'warn')}**\n\n"
            f"**Commands:**\n"
            f"`/linkprotect on` — Enable\n"
            f"`/linkprotect off` — Disable\n"
            f"`/linkprotect warn 3` — Warning limit\n"
            f"`/linkprotect action warn/mute/ban`\n"
            f"`/resetwarn @user` — Reset warnings"
        )
        return

    sub = args[1].lower()
    if sub in ["on", "off"]:
        await update_group_setting(chat_id, "link_protection", sub == "on")
        await message.reply(f"🛡 Link Protection: **{sub.upper()}**!")
    elif sub == "warn" and len(args) > 2:
        try:
            limit = int(args[2])
            await update_group_setting(chat_id, "link_warn_limit", limit)
            await message.reply(f"⚠️ Warn limit: **{limit}**")
        except:
            await message.reply("❌ Valid number do.")
    elif sub == "action" and len(args) > 2:
        action = args[2].lower()
        if action in ["warn", "mute", "ban"]:
            await update_group_setting(chat_id, "link_action", action)
            await message.reply(f"🛡 Action: **{action.upper()}**!")
        else:
            await message.reply("❌ Options: `warn` / `mute` / `ban`")

@bot.on_message(filters.command("resetwarn"))
async def reset_warn_cmd(client, message: Message):
    if message.chat.type == enums.ChatType.PRIVATE: return
    uid = message.from_user.id
    chat_id = message.chat.id
    try:
        member = await client.get_chat_member(chat_id, uid)
        is_admin = member.status in [enums.ChatMemberStatus.OWNER, enums.ChatMemberStatus.ADMINISTRATOR] or uid in ADMINS
    except:
        is_admin = uid in ADMINS
    if not is_admin:
        await message.reply("❌ Sirf admins!"); return

    if message.reply_to_message and message.reply_to_message.from_user:
        target_uid = message.reply_to_message.from_user.id
    elif len(message.command) > 1:
        try:
            target_uid = int(message.command[1])
        except:
            await message.reply("Usage: Reply to user or `/resetwarn user_id`")
            return
    else:
        await message.reply("Usage: Reply to user or `/resetwarn user_id`")
        return

    await reset_user_warns(chat_id, target_uid)
    await message.reply(f"✅ `{target_uid}` ki warnings reset kar di!")

# ═══════════════════════════════════════
#  CALLBACKS — ALL FIXED
# ═══════════════════════════════════════
@bot.on_callback_query()
async def cb_handler(client, query: CallbackQuery):
    data = query.data
    uid = query.from_user.id

    # ✅ Terms Accept / Decline
    if data == "accept_terms":
        await mark_terms_accepted(uid)
        await query.answer("✅ Terms accepted! Welcome!", show_alert=False)
        try:
            await query.message.edit_text(
                "✅ **Terms Accepted!**\n\n"
                "🎬 **AsBhai Drop Bot mein Swagat hai!**\n\n"
                "Movie ya file dhundne ke liye naam type karo!\n"
                "Commands ke liye /help",
                reply_markup=InlineKeyboardMarkup([[
                    InlineKeyboardButton("🎬 Start Searching!", switch_inline_query_current_chat="")
                ],[
                    InlineKeyboardButton("💎 Premium Plans", callback_data="show_premium")
                ]])
            )
        except: pass
        return

    if data == "decline_terms":
        await query.answer("❌ Terms decline kiye — bot use nahi kar sakte.", show_alert=True)
        try:
            await query.message.edit_text(
                "❌ **Terms Decline Kiye**\n\n"
                "Bot use karne ke liye Terms accept karna zaroori hai.\n"
                "Phir se try karne ke liye /start karo."
            )
        except: pass
        return

    # ── noop ──
    if data == "noop":
        await query.answer(); return

    # ── Channel join verify ──
    if data.startswith("checkjoin_"):
        target = int(data.split("_")[1])
        if uid != target:
            await query.answer("Ye button aapke liye nahi!", show_alert=True); return
        prem = await is_premium(uid)
        joined, not_joined = await check_member_multi(uid, prem)
        if joined:
            await query.answer("✅ Join ho gaya! File aa rahi hai...", show_alert=False)
            try:
                await query.message.delete()
            except: pass
            # Pending file check karo
            user_doc = await users_col.find_one({"user_id": uid})
            pending_file_id = (user_doc or {}).get("pending_file_id", 0)
            if pending_file_id:
                await users_col.update_one(
                    {"user_id": uid},
                    {"$unset": {"pending_file_id": "", "pending_file_chat": ""}}
                )
                wait = await client.send_message(uid, "⚡ File prepare ho rahi hai... ⏳\n_Thodi der mein PM mein milegi!_")
                success, info = await send_file_to_pm(client, query.from_user, int(pending_file_id), prem)
                try:
                    await wait.delete()
                except: pass
                if not success:
                    await client.send_message(uid, f"❌ File nahi aayi: `{info}`\nGroup mein dobara search karo.")
            else:
                await client.send_message(uid, "✅ **Join Ho Gaya!** 🎉\n\nAb group mein search karo — file milegi!")
        else:
            names = ", ".join(ch.get("title", "Channel") for ch in not_joined)
            await query.answer(f"❌ Abhi join nahi kiya!\n{names}", show_alert=True)
        return

    # ══════════════════════════════════════════════════════════
    # ══════════════════════════════════════════════════════════
    # ── getf_ — File Button Click → Bot PM mein le jaaye ──
    # Flow: Group button click → PM mein Verify/ForceSub/File
    # ══════════════════════════════════════════════════════════
    if data.startswith("getf_"):
        parts = data.split("_", 2)
        if len(parts) < 3:
            await query.answer("❌ Invalid!", show_alert=True); return
        try:
            owner_uid = int(parts[1])
            msg_id = int(parts[2])
        except:
            await query.answer("❌ Invalid!", show_alert=True); return

        if uid != owner_uid and uid not in ADMINS:
            await query.answer("❌ Ye file aapke liye nahi! Apna search karo.", show_alert=True)
            return

        if await is_banned(uid):
            await query.answer("🚫 Aap banned hain!", show_alert=True); return

        me = await client.get_me()
        prem = await is_premium(uid)
        s = await get_settings()

        # Group/PM detect
        chat_id_for_sl = 0
        is_group = False
        try:
            if query.message and query.message.chat:
                chat_id_for_sl = query.message.chat.id
                is_group = query.message.chat.type in [
                    enums.ChatType.GROUP, enums.ChatType.SUPERGROUP
                ]
        except: pass

        # ── GROUP: Seedha PM open karo — koi message nahi, koi button nahi ──
        # query.answer() mein url dene se Telegram seedha PM kholta hai
        if is_group:
            start_param = f"gf_{msg_id}_{chat_id_for_sl}"
            pm_url = f"https://t.me/{me.username}?start={start_param}"
            await query.answer(url=pm_url)
            return

        # ── PM mein hai — pura flow ──

        # STEP 1: Ad Verify (shortlink ki jagah) ya Shortlink Verify
        if not prem:
            # ── AD SYSTEM (shortlink off hone pr) ──
            if AD_SYSTEM_ENABLED and KOYEB_URL:
                ad_verified = await is_ad_verified(uid)  # ✅ FIX: 3-ghante interval
                if not ad_verified:
                    ad = await ad_get_next(uid)
                    if not ad:
                        logger.warning(f"AD_SYSTEM ON but no active ad uid={uid}")
                        pass
                    if ad:
                        token = await make_token(uid, "av")
                        from urllib.parse import quote as _qp
                        _sl_url = ""
                        if ad.get("shortlink_enabled") and ad.get("shortlink_url") and ad.get("shortlink_api"):
                            # ✅ FIX: Shortlink target = ad URL (user lands on ad after shortlink, then comes back)
                            _verify_url = ad.get("ad_url") or f"{KOYEB_URL}/"
                            _sl_url = await _generate_ad_shortlink(ad["shortlink_url"], ad["shortlink_api"], _verify_url)
                        ad_page_url = (
                            f"{KOYEB_URL}/?uid={uid}"
                            f"&avt={token}"
                            f"&adu={_qp(ad.get('ad_url',''), safe='')}"
                            f"&adl={_qp(ad.get('title',''), safe='')}"
                            f"&add={_qp(ad.get('description',''), safe='')}"
                            f"&adbn={_qp(ad.get('button_name','Visit'), safe='')}"
                            f"&adimg={_qp(ad.get('image_url',''), safe='')}"
                            f"&adsl={_qp(_sl_url, safe='')}"
                            f"&howto={_qp(ad.get('how_to_verify_url',''), safe='')}"
                            f"&adtype={ad.get('ad_type','image')}"
                            f"&advid={_qp(ad.get('video_url',''), safe='')}"
                            f"&t1={ad.get('timer1',60)}&t2={ad.get('timer2',30)}"
                        )
                        await users_col.update_one(
                            {"user_id": uid},
                            {"$set": {"pending_file_id": msg_id, "pending_file_chat": chat_id_for_sl}},
                            upsert=True
                        )
                        await query.answer()
                        await query.message.reply(
                            "🎬 **File Unlock Karo — 1 Step Only!**\n\n"
                            "📢 Ek sponsor ka page explore karo aur **free mein** apni file lo! ✅\n\n"
                            "💎 Premium users ko yeh step nahi karna!",
                            reply_markup=InlineKeyboardMarkup([[
                                InlineKeyboardButton("🔓 Unlock Karo — Ad Dekho", web_app=WebAppInfo(url=ad_page_url))
                            ],[
                                InlineKeyboardButton("❓ Verify Kaise Kare?", url="https://t.me/asbhai_bsr/667")
                            ],[
                                InlineKeyboardButton("💎 Premium lo — Ads Skip Karo!", callback_data="show_premium")
                            ]])
                        )
                        return
            # ── SHORTLINK SYSTEM (fallback agar AD_SYSTEM_ENABLED=False) ──
            elif not AD_SYSTEM_ENABLED:
                async def _grp_sl(cid):
                    sls = []
                    async for doc in group_sl_col.find({"chat_id": cid, "active": True}).sort("order", 1):
                        sls.append(doc)
                    return sls

                async def _is_grp_prem_cb(cid):
                    doc = await group_prem_col.find_one({"chat_id": cid, "status": "approved"})
                    if not doc: return False
                    exp = make_aware(doc.get("expiry"))
                    if exp and now() > exp:
                        await group_prem_col.update_one({"chat_id": cid}, {"$set": {"status": "expired"}})
                        return False
                    return True

                grp_sl_list = await _grp_sl(chat_id_for_sl) if chat_id_for_sl else []
                grp_prem_cb = await _is_grp_prem_cb(chat_id_for_sl) if chat_id_for_sl else False
                needs_verify = False
                short = None; sl_label = "Verify"; hours = 24

                if grp_prem_cb and not grp_sl_list:
                    needs_verify = False
                elif grp_sl_list:
                    sl = grp_sl_list[0]
                    sl_id = str(sl["_id"]); hours = sl.get("hours", 24)
                    log_doc = await verify_log_col.find_one(
                        {"user_id": uid, "shortlink_id": sl_id}, sort=[("verified_at", -1)]
                    )
                    if not log_doc or now() - make_aware(log_doc.get("verified_at")) >= timedelta(hours=hours):
                        needs_verify = True
                    if needs_verify:
                        token = await make_token(uid, f"sv_{sl_id}")
                        verify_url = f"https://t.me/{me.username}?start=sv_{uid}_{token}_{sl_id}"
                        short = await get_cached_shortlink(uid, chat_id_for_sl, verify_url, sl)
                        sl_label = sl.get("label", "Verify")
                elif not grp_prem_cb:
                    all_done, next_sl, _ = await get_user_verify_state(uid)
                    if not all_done and s.get("shortlink_enabled", True):
                        needs_verify = True
                        if next_sl:
                            sl_id = str(next_sl["_id"]); sl_label = next_sl.get("label", "Verify"); hours = next_sl.get("hours", 24)
                            token = await make_token(uid, f"sv_{sl_id}")
                            verify_url = f"https://t.me/{me.username}?start=sv_{uid}_{token}_{sl_id}"
                            short = await get_cached_shortlink(uid, chat_id_for_sl, verify_url, next_sl)
                        elif SHORTLINK_API:
                            token = await make_token(uid, "sv_env")
                            verify_url = f"https://t.me/{me.username}?start=sv_{uid}_{token}"
                            try:
                                api_url = f"https://{SHORTLINK_URL}/api?api={SHORTLINK_API}&url={verify_url}&format=text"
                                async with aiohttp.ClientSession() as sess:
                                    async with sess.get(api_url, timeout=aiohttp.ClientTimeout(total=10)) as r:
                                        res_text = (await r.text()).strip()
                                        short = res_text if res_text.startswith("http") else verify_url
                            except: short = verify_url
                        else:
                            needs_verify = False

                if needs_verify and short:
                    await users_col.update_one(
                        {"user_id": uid},
                        {"$set": {"pending_file_id": msg_id, "pending_file_chat": chat_id_for_sl}},
                        upsert=True
                    )
                    await query.answer()
                    await query.message.reply(
                        f"🔐 **File Lene Ke Liye Ek Step!**\n\n"
                        f"**Kaise kare:**\n"
                        f"1️⃣ Neeche **LINK** button dabao\n"
                        f"2️⃣ Page pe steps complete karo\n"
                        f"3️⃣ Wapas bot pe aao — file milegi! ✅\n\n"
                        f"⏰ Har **{hours} ghante** mein sirf ek baar\n"
                        f"💡 _Link copy karke Chrome mein bhi paste kar sakte ho_\n\n"
                        f"💎 Premium = verify bilkul nahi!",
                        reply_markup=InlineKeyboardMarkup([
                            [InlineKeyboardButton(f"🔗 {sl_label} — Verify Karo", url=short)],
                            [InlineKeyboardButton("❓ Verify Kaise Kare?", url=HOW_TO_VERIFY)],
                            [InlineKeyboardButton("💎 Premium lo — No Verify!", callback_data="show_premium")],
                        ])
                    )
                    return

        # STEP 2: Force Sub
                exp = make_aware(doc.get("expiry"))
                if exp and now() > exp:
                    await group_prem_col.update_one({"chat_id": cid}, {"$set": {"status": "expired"}})
                    return False
                return True

            grp_sl_list = await _grp_sl(chat_id_for_sl) if chat_id_for_sl else []
            grp_prem_cb = await _is_grp_prem_cb(chat_id_for_sl) if chat_id_for_sl else False
            needs_verify = False
            short = None; sl_label = "Verify"; hours = 24

            if grp_prem_cb and not grp_sl_list:
                # Group premium hai, apni shortlink nahi — global shortlink skip, seedha file
                needs_verify = False
            elif grp_sl_list:
                # Group ki apni shortlink use karo
                sl = grp_sl_list[0]
                sl_id = str(sl["_id"]); hours = sl.get("hours", 24)
                log_doc = await verify_log_col.find_one(
                    {"user_id": uid, "shortlink_id": sl_id}, sort=[("verified_at", -1)]
                )
                if not log_doc or now() - make_aware(log_doc.get("verified_at")) >= timedelta(hours=hours):
                    needs_verify = True
                if needs_verify:
                    token = await make_token(uid, f"sv_{sl_id}")
                    verify_url = f"https://t.me/{me.username}?start=sv_{uid}_{token}_{sl_id}"
                    short = await get_cached_shortlink(uid, chat_id_for_sl, verify_url, sl)
                    sl_label = sl.get("label", "Verify")
            elif not grp_prem_cb:
                # Normal group — global shortlink
                all_done, next_sl, _ = await get_user_verify_state(uid)
                if not all_done and s.get("shortlink_enabled", True):
                    needs_verify = True
                    if next_sl:
                        sl_id = str(next_sl["_id"]); sl_label = next_sl.get("label", "Verify"); hours = next_sl.get("hours", 24)
                        token = await make_token(uid, f"sv_{sl_id}")
                        verify_url = f"https://t.me/{me.username}?start=sv_{uid}_{token}_{sl_id}"
                        short = await get_cached_shortlink(uid, chat_id_for_sl, verify_url, next_sl)
                    elif SHORTLINK_API:
                        token = await make_token(uid, "sv_env")
                        verify_url = f"https://t.me/{me.username}?start=sv_{uid}_{token}"
                        try:
                            api_url = f"https://{SHORTLINK_URL}/api?api={SHORTLINK_API}&url={verify_url}&format=text"
                            async with aiohttp.ClientSession() as sess:
                                async with sess.get(api_url, timeout=aiohttp.ClientTimeout(total=10)) as r:
                                    res_text = (await r.text()).strip()
                                    short = res_text if res_text.startswith("http") else verify_url
                        except: short = verify_url
                    else:
                        needs_verify = False

            if needs_verify and short:
                await users_col.update_one(
                    {"user_id": uid},
                    {"$set": {"pending_file_id": msg_id, "pending_file_chat": chat_id_for_sl}},
                    upsert=True
                )
                await query.answer()
                await query.message.reply(
                    f"🔐 **File Lene Ke Liye Ek Step!**\n\n"
                    f"**Kaise kare:**\n"
                    f"1️⃣ Neeche **LINK** button dabao\n"
                    f"2️⃣ Page pe steps complete karo\n"
                    f"3️⃣ Wapas bot pe aao — file milegi! ✅\n\n"
                    f"⏰ Har **{hours} ghante** mein sirf ek baar\n"
                    f"💡 _Link copy karke Chrome mein bhi paste kar sakte ho_\n\n"
                    f"💎 Premium = verify bilkul nahi!",
                    reply_markup=InlineKeyboardMarkup([
                        [InlineKeyboardButton(f"🔗 {sl_label} — Verify Karo", url=short)],
                        [InlineKeyboardButton("❓ Verify Kaise Kare?", url=HOW_TO_VERIFY)],
                        [InlineKeyboardButton("💎 Premium lo — No Verify!", callback_data="show_premium")],
                    ])
                )
                return

        # STEP 2: Force Sub
        if not prem:
            joined, not_joined = await check_member_multi(uid, prem)
            if not joined:
                kb = await build_fsub_keyboard(not_joined, uid)
                names = ", ".join(ch.get("title", "Channel") for ch in not_joined)
                await query.answer()
                await query.message.reply(
                    f"📢 **Pehle Join Karo!**\n\n**{names}** join karo — phir file milegi! ✅",
                    reply_markup=kb
                )
                return

        # STEP 3: Daily Limit
        if not prem:
            count = await get_daily_count(uid)
            if count >= s.get("daily_limit", 10):
                await query.answer(
                    f"⚠️ Aaj ki limit {s.get('daily_limit', 10)} ho gayi! /premium lo.",
                    show_alert=True
                )
                return

        # STEP 4: File Send
        await query.answer("📥 File aa rahi hai...")
        success, info = await send_file_to_pm(client, query.from_user, msg_id, prem)
        if not success:
            try: await query.message.reply(f"❌ File nahi aayi.\n`{info}`")
            except: pass
        return

    # ── Group settings toggle ──
    if data.startswith("gs_toggle_"):
        parts = data.split("_")
        chat_id = int(parts[2])
        key = "_".join(parts[3:])
        gs = await get_group_settings(chat_id)
        new_val = not gs.get(key, True)
        await update_group_setting(chat_id, key, new_val)
        await query.answer(f"{'✅ ON' if new_val else '❌ OFF'}", show_alert=False)
        gs = await get_group_settings(chat_id)
        kb = _build_gsettings_kb(chat_id, gs)
        try:
            await query.message.edit_reply_markup(kb)
        except: pass
        return

    if data.startswith("gs_results_"):
        parts = data.split("_")
        chat_id = int(parts[2])
        kind = parts[3]
        key = "free_results" if kind == "free" else "premium_results"
        gs = await get_group_settings(chat_id)
        cur = gs.get(key, 5)
        cycle = [3, 5, 7, 10]
        try:
            idx = cycle.index(cur)
            new_val = cycle[(idx+1) % len(cycle)]
        except:
            new_val = 5
        await update_group_setting(chat_id, key, new_val)
        await query.answer(f"{'Free' if kind=='free' else 'Premium'}: {new_val} results")
        gs = await get_group_settings(chat_id)
        kb = _build_gsettings_kb(chat_id, gs)
        try:
            await query.message.edit_reply_markup(kb)
        except: pass
        return

    if data == "gs_done":
        await query.message.delete(); return

    # ── Result pagination ──
    if data.startswith("rpage_"):
        parts = data.split("_", 3)
        if len(parts) < 4:
            await query.answer("❌ Error", show_alert=True); return
        try:
            r_uid = int(parts[1])
            qkey = parts[2]
            page = int(parts[3])
        except:
            await query.answer("❌ Invalid data", show_alert=True); return

        if query.from_user.id != r_uid and query.from_user.id not in ADMINS:
            await query.answer("❌ Ye aapka search nahi!", show_alert=True); return

        cache_key = f"{r_uid}_{qkey}"
        found = _result_cache.get(cache_key)
        if not found:
            query_text = qkey.replace("_", " ").strip()
            prem_r = await is_premium(r_uid)
            limit_r = 10 if prem_r else 5
            found = await do_search(query_text, limit=limit_r)
            if not found:
                await query.answer("😕 Results expire ho gaye, dobara search karo", show_alert=True)
                return
            _result_cache[cache_key] = found

        page_size = 5
        total_pages = max(1, (len(found) + page_size - 1) // page_size)
        page = max(0, min(page, total_pages - 1))
        page_found = found[page * page_size:(page + 1) * page_size]

        me = await client.get_me()
        btns = _build_result_buttons(page_found, r_uid, me.username, qkey, page, total_pages)
        search_q_display = qkey.replace("_", " ").strip()
        try:
            await query.message.edit_text(
                f"🔍 **{len(found)} file mili** — `{search_q_display}`\n"
                f"📄 Page **{page+1}/{total_pages}**"
                + (f" {'◀️' if page > 0 else ''}{'▶️' if page < total_pages-1 else ''}" if total_pages > 1 else "") + "\n\n"
                f"👇 Button dabao — file PM mein seedha delivery! 📦",
                reply_markup=InlineKeyboardMarkup(btns)
            )
        except Exception as e:
            if "message is not modified" not in str(e).lower():
                logger.warning(f"rpage edit error: {e}")
        await query.answer(f"✅ Page {page+1}/{total_pages}")
        return

    # ── Language filter ──
    if data.startswith("flang_"):
        parts = data.split("_", 2)
        r_uid = int(parts[1]) if len(parts) > 1 else 0
        qkey = parts[2] if len(parts) > 2 else ""
        await query.answer("Language choose karo:")
        rows = []
        for i in range(0, len(LANGUAGES), 2):
            row = []
            for lang_name, lang_key in LANGUAGES[i:i+2]:
                row.append(InlineKeyboardButton(lang_name, callback_data=f"lang_{r_uid}_{lang_key}_{qkey}"))
            rows.append(row)
        rows.append([InlineKeyboardButton("🔙 Back", callback_data=f"fback_{r_uid}_{qkey}")])
        try:
            await query.message.edit_reply_markup(InlineKeyboardMarkup(rows))
        except: pass
        return

    if data.startswith("lang_"):
        parts = data.split("_", 3)
        r_uid = int(parts[1]) if len(parts) > 1 else 0
        lang_key = parts[2] if len(parts) > 2 else ""
        qkey = parts[3] if len(parts) > 3 else ""
        search_q = qkey.replace("_", " ").strip()
        if query.from_user.id != r_uid and query.from_user.id not in ADMINS:
            await query.answer("❌ Ye aapka button nahi!", show_alert=True); return
        await query.answer(f"🔍 {lang_key.title()} mein dhundh raha hoon...")
        combined_q = f"{search_q} {lang_key}"
        found = await do_search(combined_q, limit=10)
        if not found:
            try:
                await query.message.edit_text(
                    f"😕 {lang_key.title()} mein '{search_q}' nahi mila\n\nDusri language try karo:",
                    reply_markup=InlineKeyboardMarkup([
                        [InlineKeyboardButton("🔙 Back", callback_data=f"fback_{r_uid}_{qkey}")],
                    ])
                )
            except: pass
            return
        me = await client.get_me()
        btns = []
        for i, fmsg in enumerate(found):
            fname = get_file_name(fmsg)
            fname_clean = re.sub(r"[@#]\w+", "", re.sub(r"_+", " ", fname)).strip()
            fname_show = fname_clean[:38] if fname_clean else f"File {i+1}"
            fsize = get_file_size(fmsg)
            sz = f" [{fsize}]" if fsize else ""
            btns.append([InlineKeyboardButton(f"📥 {fname_show}{sz}", callback_data=f"getf_{r_uid}_{fmsg.id}")])
        lang_row1, lang_row2 = [], []
        for j, (lname, lkey) in enumerate(LANGUAGES):
            tick = "✅ " if lkey == lang_key else ""
            btn = InlineKeyboardButton(tick + lname.split()[-1], callback_data=f"lang_{r_uid}_{lkey}_{qkey}")
            if j < 4: lang_row1.append(btn)
            else: lang_row2.append(btn)
        if lang_row1: btns.append(lang_row1)
        if lang_row2: btns.append(lang_row2)
        btns.append([InlineKeyboardButton("🔙 Back", callback_data=f"fback_{r_uid}_{qkey}")])
        try:
            await query.message.edit_text(
                f"🌐 {lang_key.title()} — {len(found)} Results\n\n👇 File choose karo:",
                reply_markup=InlineKeyboardMarkup(btns)
            )
        except: pass
        return

    # ── Season filter ──
    if data.startswith("fseason_"):
        parts = data.split("_", 2)
        r_uid = int(parts[1]) if len(parts) > 1 else 0
        qkey = parts[2] if len(parts) > 2 else ""
        await query.answer("Season choose karo:")
        rows = []
        rows.append([InlineKeyboardButton("📦 Full Season", callback_data=f"season_{r_uid}_full_{qkey}")])
        for start in range(1, 21, 5):
            rows.append([InlineKeyboardButton(f"S{i:02d}", callback_data=f"season_{r_uid}_S{i:02d}_{qkey}") for i in range(start, start+5)])
        rows.append([
            InlineKeyboardButton("S21-S40 ▶", callback_data=f"spage_{r_uid}_21_{qkey}"),
            InlineKeyboardButton("S41+ ▶", callback_data=f"spage_{r_uid}_41_{qkey}"),
        ])
        rows.append([InlineKeyboardButton("🔙 Back", callback_data=f"fback_{r_uid}_{qkey}")])
        try:
            await query.message.edit_reply_markup(InlineKeyboardMarkup(rows))
        except: pass
        return

    if data.startswith("season_"):
        parts = data.split("_", 3)
        r_uid = int(parts[1]) if len(parts) > 1 else 0
        season_key = parts[2] if len(parts) > 2 else ""
        qkey = parts[3] if len(parts) > 3 else ""
        search_q = qkey.replace("_", " ").strip()
        if query.from_user.id != r_uid and query.from_user.id not in ADMINS:
            await query.answer("❌ Ye aapka button nahi!", show_alert=True); return
        await query.answer(f"🔍 {season_key.upper()} dhundh raha hoon...")
        combined_q = f"{search_q} {season_key}" if season_key.lower() != "full" else f"{search_q} season"
        found = await do_search(combined_q, limit=10)
        if not found:
            try:
                await query.message.edit_text(
                    f"😕 {season_key.upper()} mein '{search_q}' nahi mila",
                    reply_markup=InlineKeyboardMarkup([
                        [InlineKeyboardButton("📺 Season List", callback_data=f"fseason_{r_uid}_{qkey}")],
                        [InlineKeyboardButton("🔙 Back", callback_data=f"fback_{r_uid}_{qkey}")],
                    ])
                )
            except: pass
            return
        me = await client.get_me()
        btns = []
        for i, fmsg in enumerate(found):
            fname = get_file_name(fmsg)
            fname_clean = re.sub(r"[@#]\w+", "", re.sub(r"_+", " ", fname)).strip()
            fname_show = fname_clean[:38] if fname_clean else f"File {i+1}"
            fsize = get_file_size(fmsg)
            sz = f" [{fsize}]" if fsize else ""
            btns.append([InlineKeyboardButton(f"📥 {fname_show}{sz}", callback_data=f"getf_{r_uid}_{fmsg.id}")])
        cur = int(season_key[1:]) if season_key.startswith("S") and season_key[1:].isdigit() else 0
        s_row = []
        for sn in [max(1,cur-1), cur, min(50,cur+1)]:
            tick = "✅" if sn == cur else f"S{sn:02d}"
            s_row.append(InlineKeyboardButton(tick, callback_data=f"season_{r_uid}_S{sn:02d}_{qkey}"))
        btns.append(s_row)
        btns.append([
            InlineKeyboardButton("📺 Season List", callback_data=f"fseason_{r_uid}_{qkey}"),
            InlineKeyboardButton("🔙 Back", callback_data=f"fback_{r_uid}_{qkey}"),
        ])
        try:
            await query.message.edit_text(
                f"📺 {season_key.upper()} — {len(found)} Results\n\n👇 File choose karo:",
                reply_markup=InlineKeyboardMarkup(btns)
            )
        except: pass
        return

    if data.startswith("spage_"):
        parts = data.split("_", 3)
        r_uid = int(parts[1]) if len(parts) > 1 else 0
        start = int(parts[2]) if len(parts) > 2 else 21
        search_q = parts[3] if len(parts) > 3 else ""
        end = min(start + 19, 100)
        buttons = []
        for i in range(start, end+1, 5):
            row = [InlineKeyboardButton(f"S{j:02d}", callback_data=f"season_{r_uid}_S{j:02d}_{search_q[:15]}") for j in range(i, min(i+5, end+1))]
            buttons.append(row)
        nav = []
        if start > 1:
            prev = max(1, start - 20)
            nav.append(InlineKeyboardButton(f"◀️ S{prev:02d}-S{start-1:02d}", callback_data=f"spage_{r_uid}_{prev}_{search_q[:15]}"))
        if end < 100:
            nav.append(InlineKeyboardButton(f"▶️ S{end+1:02d}-S{min(end+20,100):02d}", callback_data=f"spage_{r_uid}_{end+1}_{search_q[:15]}"))
        if nav: buttons.append(nav)
        buttons.append([InlineKeyboardButton("🔙 Back", callback_data=f"fseason_{r_uid}_{search_q[:20]}")])
        await query.message.edit_reply_markup(InlineKeyboardMarkup(buttons))
        await query.answer(f"Season {start}-{end}")
        return

    # ── Episode filter ──
    if data.startswith("fepisode_"):
        parts = data.split("_", 2)
        r_uid = int(parts[1]) if len(parts) > 1 else 0
        qkey = parts[2] if len(parts) > 2 else ""
        await query.answer("Episode choose karo:")
        rows = []
        rows.append([InlineKeyboardButton("📦 All Episodes", callback_data=f"ep_{r_uid}_all_{qkey}")])
        for start in range(1, 21, 5):
            rows.append([InlineKeyboardButton(f"E{i:02d}", callback_data=f"ep_{r_uid}_E{i:02d}_{qkey}") for i in range(start, start+5)])
        rows.append([
            InlineKeyboardButton("E21-E40 ▶", callback_data=f"epage_{r_uid}_21_{qkey}"),
            InlineKeyboardButton("E41+ ▶", callback_data=f"epage_{r_uid}_41_{qkey}"),
        ])
        rows.append([InlineKeyboardButton("🔙 Back", callback_data=f"fback_{r_uid}_{qkey}")])
        try:
            await query.message.edit_reply_markup(InlineKeyboardMarkup(rows))
        except: pass
        return

    if data.startswith("ep_"):
        parts = data.split("_", 3)
        r_uid = int(parts[1]) if len(parts) > 1 else 0
        ep_key = parts[2] if len(parts) > 2 else ""
        qkey = parts[3] if len(parts) > 3 else ""
        search_q = qkey.replace("_", " ").strip()
        if query.from_user.id != r_uid and query.from_user.id not in ADMINS:
            await query.answer("❌ Ye aapka button nahi!", show_alert=True); return
        await query.answer(f"🔍 {ep_key.upper()} dhundh raha hoon...")
        combined_q = f"{search_q} {ep_key}" if ep_key.lower() != "all" else f"{search_q} episode"
        found = await do_search(combined_q, limit=10)
        if not found:
            try:
                await query.message.edit_text(
                    f"😕 {ep_key.upper()} mein '{search_q}' nahi mila",
                    reply_markup=InlineKeyboardMarkup([
                        [InlineKeyboardButton("🎬 Episode List", callback_data=f"fepisode_{r_uid}_{qkey}")],
                        [InlineKeyboardButton("🔙 Back", callback_data=f"fback_{r_uid}_{qkey}")],
                    ])
                )
            except: pass
            return
        me = await client.get_me()
        btns = []
        for i, fmsg in enumerate(found):
            fname = get_file_name(fmsg)
            fname_clean = re.sub(r"[@#]\w+", "", re.sub(r"_+", " ", fname)).strip()
            fname_show = fname_clean[:38] if fname_clean else f"File {i+1}"
            fsize = get_file_size(fmsg)
            sz = f" [{fsize}]" if fsize else ""
            btns.append([InlineKeyboardButton(f"📥 {fname_show}{sz}", callback_data=f"getf_{r_uid}_{fmsg.id}")])
        cur = int(ep_key[1:]) if ep_key.startswith("E") and ep_key[1:].isdigit() else 0
        ep_row = []
        for en in [max(1,cur-1), cur, min(200,cur+1)]:
            tick = "✅" if en == cur else f"E{en:02d}"
            ep_row.append(InlineKeyboardButton(tick, callback_data=f"ep_{r_uid}_E{en:02d}_{qkey}"))
        btns.append(ep_row)
        btns.append([
            InlineKeyboardButton("🎬 Episode List", callback_data=f"fepisode_{r_uid}_{qkey}"),
            InlineKeyboardButton("🔙 Back", callback_data=f"fback_{r_uid}_{qkey}"),
        ])
        try:
            await query.message.edit_text(
                f"🎬 {ep_key.upper()} — {len(found)} Results\n\n👇 File choose karo:",
                reply_markup=InlineKeyboardMarkup(btns)
            )
        except: pass
        return

    if data.startswith("epage_"):
        parts = data.split("_", 3)
        r_uid = int(parts[1]) if len(parts) > 1 else 0
        start = int(parts[2]) if len(parts) > 2 else 21
        search_q = parts[3] if len(parts) > 3 else ""
        end = min(start + 19, 100)
        buttons = []
        for i in range(start, end+1, 5):
            row = [InlineKeyboardButton(f"E{j:02d}", callback_data=f"ep_{r_uid}_E{j:02d}_{search_q[:15]}") for j in range(i, min(i+5, end+1))]
            buttons.append(row)
        nav = []
        if start > 1:
            prev = max(1, start - 20)
            nav.append(InlineKeyboardButton(f"◀️ E{prev:02d}-E{start-1:02d}", callback_data=f"epage_{r_uid}_{prev}_{search_q[:15]}"))
        if end < 100:
            nav.append(InlineKeyboardButton(f"▶️ E{end+1:02d}-E{min(end+20,100):02d}", callback_data=f"epage_{r_uid}_{end+1}_{search_q[:15]}"))
        if nav: buttons.append(nav)
        buttons.append([InlineKeyboardButton("🔙 Back", callback_data=f"fepisode_{r_uid}_{search_q[:20]}")])
        await query.message.edit_reply_markup(InlineKeyboardMarkup(buttons))
        await query.answer(f"Episode {start}-{end}")
        return

    # ── Send All ──
    if data.startswith("fsendall_"):
        parts = data.split("_", 2)
        r_uid = int(parts[1]) if len(parts) > 1 else 0
        qkey = parts[2] if len(parts) > 2 else ""
        search_q = qkey.replace("_", " ").strip()
        if query.from_user.id != r_uid and query.from_user.id not in ADMINS:
            await query.answer("❌ Ye aapka button nahi!", show_alert=True); return

        prem = await is_premium(uid)
        s = await get_settings()

        # STEP 1: Shortlink verify check
        chat_id_sa = 0
        try:
            if query.message and query.message.chat:
                chat_id_sa = query.message.chat.id
        except: pass

        if not prem:
            # ── AD SYSTEM ──
            if AD_SYSTEM_ENABLED and KOYEB_URL:
                ad_verified_sa = await is_ad_verified(uid)  # ✅ FIX: 3-ghante interval
                if not ad_verified_sa:
                    ad = await ad_get_next(uid)
                    if not ad:
                        logger.warning(f"AD_SYSTEM ON but no active ad uid={uid}")
                        pass
                    if ad:
                        from urllib.parse import quote as _qp
                        token_sa = await make_token(uid, "av")
                        _sl_url_sa = ""
                        if ad.get("shortlink_enabled") and ad.get("shortlink_url") and ad.get("shortlink_api"):
                            _verify_url_sa = ad.get("ad_url") or f"{KOYEB_URL}/"
                            _sl_url_sa = await _generate_ad_shortlink(ad["shortlink_url"], ad["shortlink_api"], _verify_url_sa)
                        ad_page_url_sa = (
                            f"{KOYEB_URL}/?uid={uid}"
                            f"&avt={token_sa}"
                            f"&adu={_qp(ad.get('ad_url',''), safe='')}"
                            f"&adl={_qp(ad.get('title',''), safe='')}"
                            f"&add={_qp(ad.get('description',''), safe='')}"
                            f"&adbn={_qp(ad.get('button_name','Visit'), safe='')}"
                            f"&adimg={_qp(ad.get('image_url',''), safe='')}"
                            f"&adsl={_qp(_sl_url_sa, safe='')}"
                            f"&howto={_qp(ad.get('how_to_verify_url',''), safe='')}"
                            f"&adtype={ad.get('ad_type','image')}"
                            f"&advid={_qp(ad.get('video_url',''), safe='')}"
                            f"&t1={ad.get('timer1',60)}&t2={ad.get('timer2',30)}"
                        )
                        await query.answer()
                        try:
                            await client.send_message(
                                uid,
                                "🎬 **File Unlock Karo — 1 Step Only!**\n\n"
                                "📢 Ek sponsor ka page explore karo aur **free mein** apni file lo! ✅\n\n"
                                "💎 Premium users ko yeh step nahi karna!",
                                reply_markup=InlineKeyboardMarkup([[
                                    InlineKeyboardButton("🔓 Unlock Karo — Ad Dekho", web_app=WebAppInfo(url=ad_page_url_sa))
                                ],[
                                    InlineKeyboardButton("❓ Verify Kaise Kare?", url="https://t.me/asbhai_bsr/667")
                                ],[
                                    InlineKeyboardButton("💎 Premium lo — Ads Skip Karo!", callback_data="show_premium")
                                ]])
                            )
                        except: pass
                        return
            # ── SHORTLINK SYSTEM (fallback) ──
            elif not AD_SYSTEM_ENABLED:
                # Group shortlink check
                grp_sl_sa = []
                if chat_id_sa:
                    async for doc in group_sl_col.find({"chat_id": chat_id_sa, "active": True}).sort("order", 1):
                        grp_sl_sa.append(doc)

                needs_verify_sa = False
                short_sa = None; sl_label_sa = "Verify"; hours_sa = 24

                if grp_sl_sa:
                    sl = grp_sl_sa[0]
                    sl_id = str(sl["_id"]); hours_sa = sl.get("hours", 24)
                    log_doc = await verify_log_col.find_one({"user_id": uid, "shortlink_id": sl_id}, sort=[("verified_at", -1)])
                    if not log_doc or now() - make_aware(log_doc.get("verified_at")) >= timedelta(hours=hours_sa):
                        needs_verify_sa = True
                        me_sa = await client.get_me()
                        token_sa = await make_token(uid, f"sv_{sl_id}")
                        verify_url_sa = f"https://t.me/{me_sa.username}?start=sv_{uid}_{token_sa}_{sl_id}"
                        short_sa = await get_cached_shortlink(uid, chat_id_sa, verify_url_sa, sl)
                        sl_label_sa = sl.get("label", "Verify")
                else:
                    all_done_sa, next_sl_sa, _ = await get_user_verify_state(uid)
                    if not all_done_sa and s.get("shortlink_enabled", True):
                        needs_verify_sa = True
                        me_sa = await client.get_me()
                        if next_sl_sa:
                            sl_id = str(next_sl_sa["_id"]); sl_label_sa = next_sl_sa.get("label", "Verify"); hours_sa = next_sl_sa.get("hours", 24)
                            token_sa = await make_token(uid, f"sv_{sl_id}")
                            verify_url_sa = f"https://t.me/{me_sa.username}?start=sv_{uid}_{token_sa}_{sl_id}"
                            short_sa = await get_cached_shortlink(uid, chat_id_sa, verify_url_sa, next_sl_sa)
                        elif SHORTLINK_API:
                            token_sa = await make_token(uid, "sv_env")
                            verify_url_sa = f"https://t.me/{me_sa.username}?start=sv_{uid}_{token_sa}"
                            try:
                                api_url_sa = f"https://{SHORTLINK_URL}/api?api={SHORTLINK_API}&url={verify_url_sa}&format=text"
                                async with aiohttp.ClientSession() as sess:
                                    async with sess.get(api_url_sa, timeout=aiohttp.ClientTimeout(total=10)) as r:
                                        result_sa = (await r.text()).strip()
                                        short_sa = result_sa if result_sa.startswith("http") else verify_url_sa
                            except: short_sa = verify_url_sa
                        else:
                            needs_verify_sa = False

                if needs_verify_sa and short_sa:
                    await query.answer()
                    try:
                        await client.send_message(
                            uid,
                            f"🔐 **Ek Chhota Sa Step!**\n\n"
                            f"👇 Shortlink complete karo → sab files milegi!\n"
                            f"⏰ Har {hours_sa} ghante mein ek baar.\n\n"
                            f"💎 Premium lo = verify kabhi nahi!",
                            reply_markup=InlineKeyboardMarkup([
                                [InlineKeyboardButton(f"🔗 {sl_label_sa} — Verify Karo", url=short_sa)],
                                [InlineKeyboardButton("❓ Verify Kaise Kare?", url=HOW_TO_VERIFY)],
                                [InlineKeyboardButton("💎 Premium lo", callback_data="show_premium")],
                            ])
                        )
                    except: pass
                    return

        # STEP 2: Force sub
        if not prem:
            joined_sa, not_joined_sa = await check_member_multi(uid, prem)
            if not joined_sa:
                kb_sa = await build_fsub_keyboard(not_joined_sa, uid)
                await query.answer()
                try:
                    names_sa = ", ".join(ch.get("title", "Channel") for ch in not_joined_sa)
                    await client.send_message(
                        uid,
                        f"📢 **Pehle Join Karo!**\n\n**{names_sa}** join karo — phir files milegi! ✅",
                        reply_markup=kb_sa
                    )
                except: pass
                return

        await query.answer("📤 Sab files PM mein bhej raha hoon... Thoda wait karo!")
        cache_key = f"{r_uid}_{qkey}"
        found = _result_cache.get(cache_key) or await do_search(search_q, limit=10)
        if not found:
            await query.answer("😕 Koi file nahi mili!", show_alert=True); return
        t = s.get("auto_delete_time", 300)
        sent_count = 0
        fail_count = 0
        flood_hit = False
        for fmsg in found:
            if flood_hit:
                break
            try:
                # FIX: Re-fetch message for fresh file_reference to avoid expired errors
                fresh_msg = await client.get_messages(FILE_CHANNEL, fmsg.id)
                if not fresh_msg or fresh_msg.empty:
                    fail_count += 1
                    continue

                fname = get_file_name(fresh_msg)
                fsize = get_file_size(fresh_msg)
                size_txt = f"📦 {fsize}\n" if fsize else ""

                # Stream button for premium
                kb = None
                if prem and KOYEB_URL:
                    stream_url = f"{KOYEB_URL}/?uid={r_uid}&mid={fresh_msg.id}"
                    dl_url = f"{KOYEB_URL}/download/{fresh_msg.id}?uid={r_uid}"
                    kb = InlineKeyboardMarkup([
                        [
                            InlineKeyboardButton("▶️ Stream", web_app=WebAppInfo(url=stream_url)),
                            InlineKeyboardButton("⬇️ Download", url=dl_url)
                        ]
                    ])

                cap = (
                    f"🗂 {fname}\n{size_txt}\n"
                    f"⏳ {t//60} min baad delete hogi! Save kar lo! 📌"
                )
                sent = await fresh_msg.copy(
                    chat_id=query.from_user.id,
                    caption=cap,
                    parse_mode=enums.ParseMode.MARKDOWN,
                    reply_markup=kb
                )
                await increment_daily(r_uid)
                if s.get("auto_delete"):
                    asyncio.create_task(del_later(sent, t))
                sent_count += 1
                # FIX: Longer delay between sends to avoid PEER_FLOOD
                await asyncio.sleep(1.5)
            except FloodWait as e:
                logger.warning(f"sendall FloodWait {e.value}s uid={r_uid}")
                if e.value > 30:
                    flood_hit = True
                else:
                    await asyncio.sleep(e.value + 2)
            except Exception as e:
                err_name = type(e).__name__
                if "PEER_FLOOD" in str(e) or "PeerFlood" in err_name:
                    logger.error(f"sendall PEER_FLOOD — stopping")
                    flood_hit = True
                else:
                    logger.error(f"sendall copy error: {e}")
                    fail_count += 1
        
        status_emoji = "✅" if sent_count > 0 else "⚠️"
        flood_msg = "\n⚠️ Rate limit laga — baaki baad mein try karo." if flood_hit else ""
        fail_msg = f"\n❌ {fail_count} files fail." if fail_count > 0 else ""
        try:
            await query.message.edit_text(
                f"{status_emoji} **{sent_count}/{len(found)} files** PM mein bhej di!\n"
                f"📌 Save kar lo — {t//60} min baad delete hongi!"
                f"{flood_msg}{fail_msg}"
            )
        except: pass
        return

    # ── Back button ──
    if data.startswith("fback_"):
        parts = data.split("_", 2)
        r_uid = int(parts[1]) if len(parts) > 1 else 0
        qkey = parts[2] if len(parts) > 2 else ""
        search_q = qkey.replace("_", " ").strip()
        if query.from_user.id != r_uid and query.from_user.id not in ADMINS:
            await query.answer("❌ Ye button aapke liye nahi!", show_alert=True); return
        await query.answer("🔄 Original results...")
        cache_key = f"{r_uid}_{qkey}"
        found = _result_cache.get(cache_key) or await do_search(search_q, limit=10)
        if not found:
            await query.message.edit_text(f"😕 '{search_q}' nahi mila"); return
        _result_cache[cache_key] = found
        me = await client.get_me()
        page_size = 5
        total_pages = max(1, (len(found) + page_size - 1) // page_size)
        btns = _build_result_buttons(found[:page_size], r_uid, me.username, qkey, 0, total_pages)
        page_hint = f"\n📄 Page **1/{total_pages}** — Next ke liye ▶️ dabao" if total_pages > 1 else ""
        try:
            await query.message.edit_text(
                f"📂 **{len(found)} file mili** — `{search_q}`{page_hint}\n\n"
                f"👇 Button dabao — PM mein seedha delivery! 📦",
                reply_markup=InlineKeyboardMarkup(btns)
            )
        except: pass
        return

    # ── Premium/Help/Stats callbacks ──
    if data == "refer_info":
        doc = await users_col.find_one({"user_id": uid})
        refer_count = doc.get("refer_count", 0) if doc else 0
        needed = 10 - (refer_count % 10) if refer_count % 10 != 0 else 10
        me = await client.get_me()
        ref_link = f"https://t.me/{me.username}?start=ref_{uid}"
        await query.message.edit(
            f"🔗 **Refer & Earn**\n\n"
            f"Link: `{ref_link}`\n\n"
            f"📊 Refers: **{refer_count}**\n"
            f"🎯 Next Premium: **{needed}** aur\n\n"
            f"**Reward:** Har 10 refer = 15 din FREE Premium 💎",
            reply_markup=InlineKeyboardMarkup([
                [InlineKeyboardButton("📤 Share", url=f"https://t.me/share/url?url={ref_link}&text=Free+movies+download+karo!")],
                [InlineKeyboardButton("🔙 Back", callback_data="back_main")]
            ])
        )
        return

    if data == "show_premium":
        await query.answer()
        miniapp_url = _miniapp_url(uid, getattr(query.from_user,'first_name',None) or 'User')
        # ✅ Directly open mini app premium page
        premium_url = miniapp_url.replace("/?uid=", "/?page=premium&uid=") if miniapp_url else None
        prem = await is_premium(uid)
        exp  = await get_premium_expiry(uid)
        exp_str = exp.astimezone(IST).strftime("%d %b %Y") if exp else "N/A"
        kb_btns = []
        if premium_url:
            kb_btns.append([InlineKeyboardButton("💎 Premium Plans Dekho — Mini App", web_app=WebAppInfo(url=premium_url))])
        kb_btns += [
            [InlineKeyboardButton("🔗 Refer Karo — Free Premium", callback_data="refer_info")],
            [InlineKeyboardButton("🆘 Support", url=SUPPORT_LINK)],
            [InlineKeyboardButton("🔙 Back", callback_data="back_main")]
        ]
        try:
            await query.message.edit(
                f"💎 **Premium**\n\n"
                f"Status: {'✅ Active' if prem else '❌ Nahi'}\n"
                f"Expiry: {exp_str}\n\n"
                f"**Benefits:**\n"
                f"• 🔓 Ads bypass — Bina verify ke files\n"
                f"• 🔗 `/streamlink` — Video stream links\n"
                f"• 📦 Unlimited search results\n"
                f"• ▶️ HD Stream + Download\n"
                f"• ∞ Unlimited downloads\n"
                f"• ⚡ Instant delivery\n\n"
                f"👇 Mini App mein plans dekho aur kharido!",
                reply_markup=InlineKeyboardMarkup(kb_btns)
            )
        except:
            pass
        return

    # ✅ Streamlink cancel
    if data == "streamlink_cancel":
        await query.answer("❌ Cancelled", show_alert=False)
        _streamlink_waiting.pop(uid, None)
        try: await query.message.delete()
        except: pass
        return

    if data == "buy_premium":
        miniapp_url = _miniapp_url(uid, getattr(query.from_user,'first_name',None) or 'User')
        await query.answer()
        buttons = []
        if miniapp_url:
            buttons.append([InlineKeyboardButton("🌐 Mini App mein Plans Dekho", web_app=WebAppInfo(url=miniapp_url))])
        buttons.append([InlineKeyboardButton("🔙 Back", callback_data="show_premium")])
        try:
            await query.message.edit(
                "💎 **Premium Kharidein**\n\n"
                "🥈 Silver ₹50 (10 din)\n"
                "🥇 Gold ₹150 (30 din)\n"
                "💎 Diamond ₹200 (60 din)\n"
                "👑 Elite ₹800 (1 saal)\n\n"
                "Mini App mein plan choose karo → Pay karo → Active!",
                reply_markup=InlineKeyboardMarkup(buttons)
            )
        except: pass
        return

    if data == "help":
        await query.message.edit(
            "📖 **Bot Guide**\n\n"
            "**Kaise use karein:**\n"
            "1️⃣ Channel join karo\n"
            "2️⃣ Shortlink verify karo\n"
            "3️⃣ Group mein naam type karo\n"
            "4️⃣ Button dabao → PM mein file!\n\n"
            "⚠️ File auto delete hogi — save karo!\n\n"
            "💎 Premium = No verify + 10 results + stream!\n"
            "🔗 10 Refer = 15 din free premium!\n\n"
            "━━━━━━━━━━━━━━━━\n"
            "**Bot Premium vs Group Premium:**\n\n"
            "🔹 **Bot Premium (₹50-₹800):**\n"
            "  → Aapke personal use ke liye\n"
            "  → No verify, no force join\n"
            "  → 10 results, unlimited downloads\n"
            "  → Stream + Download + PM search\n\n"
            "🔹 **Group Premium (₹300-₹550):**\n"
            "  → Aapke GROUP ke liye\n"
            "  → Apni SHORTLINK lagao group mein\n"
            "  → Jab koi user verify kare = AAPKI earning!\n"
            "  → Bot ka paisa alag, aapka paisa alag\n"
            "  → Group ke sab users ko benefit\n\n"
            "Summary: Bot Premium = USER ke liye skip\n"
            "Group Premium = OWNER ke liye earning! 💸\n\n"
            "━━━━━━━━━━━━━━━━\n"
            "🆘 **Koi problem?** Neeche Support button dabao!",
            reply_markup=InlineKeyboardMarkup([
                [InlineKeyboardButton("🆘 Support", url=SUPPORT_LINK)],
                [InlineKeyboardButton("🔙 Back", callback_data="back_main")]
            ])
        )
        return

    if data == "my_stats":
        prem = await is_premium(uid)
        count = await get_daily_count(uid)
        doc = await users_col.find_one({"user_id": uid})
        joined = make_aware(doc["joined"]).astimezone(IST).strftime("%d %b %Y") if doc and doc.get("joined") else "N/A"
        today = now_ist().strftime("%Y-%m-%d")
        verified = bool(doc and doc.get("verified_date") == today) if doc else False
        refers = doc.get("refer_count", 0) if doc else 0
        s = await get_settings()
        limit = "∞" if prem else str(s.get("daily_limit", 10))
        exp = await get_premium_expiry(uid)
        exp_str = exp.astimezone(IST).strftime("%d %b %Y") if exp else "N/A"
        await query.message.edit(
            f"📊 **Aapki Stats**\n\n"
            f"👤 {query.from_user.mention}\n"
            f"🆔 `{uid}`\n"
            f"📅 Joined: {joined}\n"
            f"💎 Premium: {'✅ — ' + exp_str if prem else '❌'}\n"
            f"✅ Verified: {'Haan' if verified or prem else 'Nahi'}\n"
            f"📥 Downloads: {count}/{limit}\n"
            f"🔗 Refers: {refers}",
            reply_markup=InlineKeyboardMarkup([
                [InlineKeyboardButton("🔙 Back", callback_data="back_main")]
            ])
        )
        return

    if data == "back_main":
        me = await client.get_me()
        miniapp_url = _miniapp_url(uid, getattr(query.from_user,'first_name',None) or 'User')
        buttons = [
            [
                InlineKeyboardButton("📢 Channel", url=f"https://t.me/{FORCE_SUB_CHANNEL.replace('@','')}"),
                InlineKeyboardButton("💎 Premium", callback_data="show_premium")
            ],
            [
                InlineKeyboardButton("ℹ️ Help", callback_data="help"),
                InlineKeyboardButton("📊 My Stats", callback_data="my_stats")
            ],
            [InlineKeyboardButton("🔗 Refer & Earn", callback_data="refer_info")],
            [InlineKeyboardButton("🆘 Support", url=SUPPORT_LINK)]
        ]
        if miniapp_url:
            buttons.append([InlineKeyboardButton("🌐 Mini App", web_app=WebAppInfo(url=miniapp_url))])
        await query.message.edit(
            "🗂 **AsBhai Drop Bot**\n\nGroup mein file naam type karo!",
            reply_markup=InlineKeyboardMarkup(buttons)
        )
        return

    if data == "need_premium":
        await query.answer("💎 Sirf Premium ke liye! /premium type karo.", show_alert=True)
        return

    if data == "pm_settings":
        prem = await is_premium(uid)
        doc = await users_col.find_one({"user_id": uid})
        prem_res = doc.get("prem_results_pref", 10) if doc else 10
        kb = InlineKeyboardMarkup([
            [InlineKeyboardButton(f"📊 Results: {prem_res}", callback_data="pmsett_results")],
            [InlineKeyboardButton("🔙 Back", callback_data="back_main")]
        ])
        await query.message.edit(
            f"⚙️ **PM Settings**\n\n💎 Premium: {'✅' if prem else '❌'}\nResults: **{prem_res}**",
            reply_markup=kb
        )
        return

    if data == "pmsett_results":
        prem = await is_premium(uid)
        if not prem:
            await query.answer("💎 Sirf Premium users!", show_alert=True); return
        doc = await users_col.find_one({"user_id": uid})
        cur = doc.get("prem_results_pref", 10) if doc else 10
        cycle = [5, 7, 10]
        try: idx = cycle.index(cur); new_val = cycle[(idx+1) % len(cycle)]
        except: new_val = 10
        await users_col.update_one({"user_id": uid}, {"$set": {"prem_results_pref": new_val}}, upsert=True)
        await query.answer(f"✅ Results: {new_val}")
        return

    # ── Payment approve/reject ──
    if data.startswith("pay_approve_"):
        if query.from_user.id not in ADMINS:
            await query.answer("❌ Sirf owner!", show_alert=True); return
        parts = data.split("_")
        pay_id = parts[2]
        user_id = int(parts[3])
        days = int(parts[4])
        pay_doc = await payments_col.find_one({"_id": ObjectId(pay_id)})
        await payments_col.update_one(
            {"_id": ObjectId(pay_id)},
            {"$set": {"status": "approved", "approved_at": now(), "approved_by": query.from_user.id}}
        )
        if pay_doc and pay_doc.get("group_id"):
            try:
                g_id = int(pay_doc["group_id"])
            except (ValueError, TypeError):
                await query.answer("❌ Invalid Group ID! Sahi group ID daalo.", show_alert=True)
                await send_log(f"⚠️ #InvalidGroupID\nPay ID: {pay_id}\nGroup ID: `{pay_doc['group_id']}`\nUser: `{user_id}`")
                return
            expiry = now() + timedelta(days=days)
            await group_prem_col.update_one(
                {"chat_id": g_id},
                {"$set": {"chat_id": g_id, "owner_id": user_id, "status": "approved",
                          "expiry": expiry, "days": days, "approved_at": now()}},
                upsert=True
            )
            me = await client.get_me()
            try:
                await client.send_message(
                    user_id,
                    f"🎉 **Group Premium Approved!** 🏆\n\n"
                    f"🏘 Group ID: `{g_id}`\n"
                    f"📅 **{days} din** ke liye active!\n"
                    f"⏰ Expiry: {expiry.astimezone(IST).strftime('%d %b %Y')}\n\n"
                    f"**Ab kya karein:**\n"
                    f"1️⃣ Group mein @{me.username} add karo\n"
                    f"2️⃣ Shortlink lagao:\n"
                    f"   `/gshortlink YOUR_API modijiurl.com 6 Label`\n"
                    f"3️⃣ Users search karenge = aapki shortlink aayegi! 💸"
                )
            except: pass
            await query.message.edit_reply_markup(None)
            await query.message.reply(f"✅ Group `{g_id}` ko **{days} din** Group Premium!")
            await query.answer("✅ Group Premium Approved!")
            await send_log(f"✅ #PaymentApproved Group\n`{g_id}` — {days} din — by {query.from_user.id}")
            return
        await add_premium(user_id, days)
        exp = await get_premium_expiry(user_id)
        exp_str = exp.astimezone(IST).strftime("%d %b %Y") if exp else "N/A"
        try:
            await client.send_message(
                user_id,
                f"🎉 **Premium Approved!**\n\n"
                f"**{days} din** Premium activate! 💎\n"
                f"Expiry: **{exp_str}**\n\n"
                f"Ab enjoy karo — no verify, no force join! 🗂"
            )
        except: pass
        await query.message.edit_reply_markup(None)
        await query.message.reply(f"✅ `{user_id}` ko **{days} din** Premium!")
        await query.answer("✅ Approved!")
        await send_log(f"✅ #PaymentApproved User\n`{user_id}` — {days} din — by {query.from_user.id}")
        return

    if data.startswith("pay_reject_"):
        if query.from_user.id not in ADMINS:
            await query.answer("❌ Sirf owner!", show_alert=True); return
        parts = data.split("_")
        pay_id = parts[2]
        user_id = int(parts[3])
        await payments_col.update_one(
            {"_id": ObjectId(pay_id)},
            {"$set": {"status": "rejected", "rejected_at": now()}}
        )
        pay_doc_r = await payments_col.find_one({"_id": ObjectId(pay_id)})
        is_grp = pay_doc_r and pay_doc_r.get("is_group")
        try:
            await client.send_message(
                user_id,
                f"❌ **Payment Rejected**\n\n"
                f"Sahi details ke saath dobara submit karo\n"
                f"ya support pe contact karo 👇",
                reply_markup=InlineKeyboardMarkup([
                    [InlineKeyboardButton("🆘 Support", url=SUPPORT_LINK)]
                ])
            )
        except: pass
        await query.message.edit_reply_markup(None)
        await query.answer("❌ Rejected!")
        await send_log(f"❌ #PaymentRejected\n`{user_id}` — by {query.from_user.id}")
        return

    # Shortlink management callbacks
    if data.startswith("sl_toggle_"):
        if query.from_user.id not in ADMINS:
            await query.answer("❌ Sirf owner!", show_alert=True); return
        sl_id = data.replace("sl_toggle_", "")
        sl = await shortlinks_col.find_one({"_id": ObjectId(sl_id)})
        if not sl:
            await query.answer("❌ Shortlink nahi mila!", show_alert=True); return
        new_val = not sl.get("active", True)
        await shortlinks_col.update_one({"_id": ObjectId(sl_id)}, {"$set": {"active": new_val}})
        await query.answer(f"{'✅ Enabled' if new_val else '🔴 Disabled'}")
        return

    if data.startswith("sl_remove_"):
        if query.from_user.id not in ADMINS:
            await query.answer("❌ Sirf owner!", show_alert=True); return
        sl_id = data.replace("sl_remove_", "")
        await shortlinks_col.delete_one({"_id": ObjectId(sl_id)})
        await query.answer("✅ Removed!")
        return

    if data == "sl_help_add":
        if query.from_user.id not in ADMINS:
            await query.answer("❌ Sirf owner!", show_alert=True); return
        await query.answer()
        await query.message.reply(
            "➕ Naya Shortlink:\n`/addshortlink <api_key> <url> <hours> [label]`"
        )
        return

    # Request callbacks
    if data.startswith("req_del_"):
        if query.from_user.id not in ADMINS:
            await query.answer("❌!", show_alert=True); return
        req_id = data.replace("req_del_", "")
        await requests_col.delete_one({"_id": ObjectId(req_id)})
        await query.message.edit_reply_markup(None)
        await query.answer("✅ Deleted!")
        return

    if data.startswith("req_done_"):
        if query.from_user.id not in ADMINS:
            await query.answer("❌!", show_alert=True); return
        parts = data.split("_", 3)
        req_uid = int(parts[2]) if len(parts) > 2 else 0
        req_q = parts[3] if len(parts) > 3 else ""
        try:
            await client.send_message(req_uid, f"✅ Aapki request `{req_q}` add ho gayi!\nSearch karke dekho!")
        except: pass
        await query.message.edit_reply_markup(None)
        await query.answer("Done!")
        return

    if data.startswith("req_skip_"):
        await query.message.edit_reply_markup(None)
        await query.answer("Skipped")
        return

    # Admin panel callbacks
    if data.startswith("ap_"):
        if query.from_user.id not in ADMINS:
            await query.answer("❌ Sirf owner!", show_alert=True); return
        sub = data[3:]
        s = await get_settings()
        if sub == "toggle_maintenance":
            new_val = not s.get("maintenance", False)
            await update_setting("maintenance", new_val)
            await query.answer(f"🔧 Maintenance: {'ON' if new_val else 'OFF'}")
        elif sub == "toggle_shortlink":
            new_val = not s.get("shortlink_enabled", True)
            await update_setting("shortlink_enabled", new_val)
            await query.answer(f"🔗 Shortlink: {'ON' if new_val else 'OFF'}")
        elif sub == "toggle_forcesub":
            new_val = not s.get("force_sub", True)
            await update_setting("force_sub", new_val)
            await query.answer(f"📢 Force sub: {'ON' if new_val else 'OFF'}")
        elif sub == "refresh":
            await query.answer("🔄 Refreshed!")
        else:
            await query.answer()
        return

    if data.startswith("grm_prem_") or data.startswith("grmprem_"):
        if query.from_user.id not in ADMINS:
            await query.answer("❌!", show_alert=True); return
        g_id = int(data.split("_")[-1])
        await group_prem_col.delete_one({"chat_id": g_id})
        await query.message.edit_reply_markup(None)
        await query.answer("✅ Group Premium removed!")
        return

    # ── Global Settings toggle callbacks ──
    if data.startswith("gs_global_"):
        if query.from_user.id not in ADMINS:
            await query.answer("❌ Sirf owner!", show_alert=True); return
        key = data[10:]  # remove "gs_global_"
        s = await get_settings()

        cycle_map = {
            "dailylimit": ([5,10,15,20,30,50], "daily_limit"),
            "freeresults": ([3,5,7,10], "free_results"),
            "premresults": ([5,10,15,20], "premium_results"),
            "deletetime": ([60,120,180,300,600,900], "auto_delete_time"),
        }
        toggle_map = {
            "maintenance": "maintenance",
            "shortlink": "shortlink_enabled",
            "forcesub": "force_sub",
            "linkprotect": "link_protection",
            "autodelete": "auto_delete",
            "tmdb": "tmdb_enabled",
        }

        if key in toggle_map:
            db_key = toggle_map[key]
            new_val = not s.get(db_key, True)
            await update_setting(db_key, new_val)
            await query.answer(f"{'✅ ON' if new_val else '❌ OFF'}")
        elif key in cycle_map:
            cycle, db_key = cycle_map[key]
            cur = s.get(db_key, cycle[0])
            try: idx = cycle.index(cur)
            except: idx = 0
            new_val = cycle[(idx + 1) % len(cycle)]
            await update_setting(db_key, new_val)
            await query.answer(f"➡️ {db_key}: {new_val}")
        elif key == "refresh":
            await query.answer("🔄 Refreshed!")

        s = await get_settings()
        kb = _build_global_settings_kb(s)
        try:
            await query.message.edit_reply_markup(kb)
        except: pass
        return

    # ── Stats admin callbacks ──
    if data.startswith("admin_"):
        if query.from_user.id not in ADMINS:
            await query.answer("❌ Sirf owner!", show_alert=True); return
        sub = data[6:]

        if sub == "clear_banned":
            count = await banned_col.count_documents({})
            await banned_col.delete_many({})
            await query.answer(f"✅ {count} banned users clear!", show_alert=True)
            return

        if sub == "clear_requests":
            count = await requests_col.count_documents({})
            await requests_col.delete_many({})
            await query.answer(f"✅ {count} requests clear!", show_alert=True)
            return

        if sub == "clear_payments":
            count = await payments_col.count_documents({"status": "pending"})
            await payments_col.delete_many({"status": "pending"})
            await query.answer(f"✅ {count} pending payments clear!", show_alert=True)
            return

        if sub == "refresh_stats":
            u = await users_col.count_documents({})
            g = await groups_col.count_documents({})
            p = await premium_col.count_documents({})
            b = await banned_col.count_documents({})
            r = await requests_col.count_documents({})
            total_refers = await refers_col.count_documents({})
            pending_pay = await payments_col.count_documents({"status": "pending"})
            try:
                await query.message.edit_text(
                    f"📊 **Bot Statistics**\n"
                    f"{'─'*28}\n"
                    f"👥 Users: **{u}** | 🏘 Groups: **{g}**\n"
                    f"💎 Premium: **{p}** | 🚫 Banned: **{b}**\n"
                    f"📩 Requests: **{r}** | 🔗 Refers: **{total_refers}**\n"
                    f"💰 Pending Payments: **{pending_pay}**\n"
                    f"{'─'*28}\n"
                    f"🕐 {now_ist().strftime('%d %b %Y %H:%M')} IST",
                    reply_markup=query.message.reply_markup
                )
            except: pass
            await query.answer("🔄 Refreshed!")
            return

        if sub == "pending_pay":
            docs = []
            async for doc in payments_col.find({"status": "pending"}).limit(10):
                docs.append(doc)
            if not docs:
                await query.answer("✅ Koi pending payment nahi!", show_alert=True); return
            text = f"💰 **Pending Payments ({len(docs)})**\n\n"
            for d in docs:
                text += f"👤 `{d.get('user_id')}` | ₹{d.get('amount','?')} | {d.get('plan','?')}\n"
            await query.message.reply(text)
            await query.answer()
            return

        if sub == "view_requests":
            docs = []
            async for doc in requests_col.find({}).sort("time", -1).limit(10):
                docs.append(doc)
            if not docs:
                await query.answer("✅ Koi request nahi!", show_alert=True); return
            text = f"📩 **Recent Requests ({len(docs)})**\n\n"
            for d in docs:
                text += f"👤 `{d.get('user_id')}` | 📁 {d.get('request','?')[:30]}\n"
            await query.message.reply(text)
            await query.answer()
            return

        await query.answer()
        return

    await query.answer()

# ═══════════════════════════════════════
#  HELPER: Group settings keyboard
# ═══════════════════════════════════════
def _build_gsettings_kb(chat_id, gs):
    return InlineKeyboardMarkup([
        [
            InlineKeyboardButton(f"{'✅' if gs.get('force_sub') else '❌'} Force Sub", callback_data=f"gs_toggle_{chat_id}_force_sub"),
            InlineKeyboardButton(f"{'✅' if gs.get('shortlink_enabled') else '❌'} Shortlink", callback_data=f"gs_toggle_{chat_id}_shortlink_enabled")
        ],
        [
            InlineKeyboardButton(f"{'✅' if gs.get('auto_delete') else '❌'} Auto Delete", callback_data=f"gs_toggle_{chat_id}_auto_delete"),
            InlineKeyboardButton(f"{'✅' if gs.get('request_mode') else '❌'} Request Mode", callback_data=f"gs_toggle_{chat_id}_request_mode")
        ],
        [
            InlineKeyboardButton(f"{'✅' if gs.get('link_protection') else '❌'} Link Protect", callback_data=f"gs_toggle_{chat_id}_link_protection"),
        ],
        [
            InlineKeyboardButton(f"📊 Free: {gs.get('free_results',5)}", callback_data=f"gs_results_{chat_id}_free"),
            InlineKeyboardButton(f"💎 Premium: {gs.get('premium_results',10)}", callback_data=f"gs_results_{chat_id}_prem")
        ],
        [InlineKeyboardButton("✅ Done", callback_data="gs_done")]
    ])

# ═══════════════════════════════════════
#  OWNER COMMANDS (same as before, keeping all)
# ═══════════════════════════════════════
@bot.on_message(filters.command(["gsettings", "gset", "groupsettings"]))
async def group_settings_cmd(client, message: Message):
    uid = message.from_user.id
    if message.chat.type == enums.ChatType.PRIVATE:
        await message.reply("⚙️ Group mein jaake `/gsettings` type karo"); return
    chat_id = message.chat.id
    try:
        member = await client.get_chat_member(chat_id, uid)
        is_admin = member.status in [enums.ChatMemberStatus.OWNER, enums.ChatMemberStatus.ADMINISTRATOR] or uid in ADMINS
    except:
        is_admin = uid in ADMINS
    if not is_admin:
        await message.reply("❌ Sirf admins!"); return
    gs = await get_group_settings(chat_id)
    kb = _build_gsettings_kb(chat_id, gs)
    await message.reply(
        f"⚙️ **{message.chat.title} — Settings**\n\n"
        f"Force Sub: {'✅' if gs.get('force_sub') else '❌'}\n"
        f"Shortlink: {'✅' if gs.get('shortlink_enabled') else '❌'}\n"
        f"Auto Delete: {'✅' if gs.get('auto_delete') else '❌'}\n"
        f"Request Mode: {'✅' if gs.get('request_mode') else '❌'}\n"
        f"Link Protection: {'✅' if gs.get('link_protection') else '❌'}\n"
        f"Free Results: {gs.get('free_results',5)}\n"
        f"Premium Results: {gs.get('premium_results',10)}\n",
        reply_markup=kb
    )

@bot.on_message(filters.command("addpremium") & filters.user(ADMINS))
async def addprem(client, message: Message):
    args = message.command
    if len(args) < 2:
        await message.reply("Usage: `/addpremium user_id [days]`"); return
    try:
        uid = int(args[1]); days = int(args[2]) if len(args) > 2 else 30
        await add_premium(uid, days)
        await message.reply(f"✅ `{uid}` ko **{days} din** Premium!")
        try: await client.send_message(uid, f"🎉 **Premium Activated!** {days} din 💎")
        except: pass
    except ValueError: await message.reply("❌ Invalid ID.")

@bot.on_message(filters.command("removepremium") & filters.user(ADMINS))
async def remprem(client, message: Message):
    args = message.command
    if len(args) < 2: await message.reply("Usage: `/removepremium user_id`"); return
    try:
        uid = int(args[1]); await remove_premium(uid)
        await message.reply(f"✅ `{uid}` ka Premium hata diya!")
    except ValueError: await message.reply("❌ Invalid ID.")

@bot.on_message(filters.command("ban") & filters.user(ADMINS))
async def ban_cmd(client, message: Message):
    args = message.command
    if len(args) < 2: await message.reply("Usage: `/ban user_id [reason]`"); return
    try:
        uid = int(args[1]); reason = " ".join(args[2:]) if len(args) > 2 else "No reason"
        await ban_user(uid, reason)
        await message.reply(f"🚫 `{uid}` banned! Reason: {reason}")
    except ValueError: await message.reply("❌ Invalid ID.")

@bot.on_message(filters.command("unban") & filters.user(ADMINS))
async def unban_cmd(client, message: Message):
    args = message.command
    if len(args) < 2: await message.reply("Usage: `/unban user_id`"); return
    try: uid = int(args[1]); await unban_user(uid); await message.reply(f"✅ `{uid}` unbanned!")
    except ValueError: await message.reply("❌ Invalid ID.")

@bot.on_message(filters.command("stats") & filters.user(ADMINS))
async def stats_cmd(client, message: Message):
    u = await users_col.count_documents({})
    g = await groups_col.count_documents({})
    p = await premium_col.count_documents({})
    b = await banned_col.count_documents({})
    r = await requests_col.count_documents({})
    total_refers = await refers_col.count_documents({})
    pending_pay = await payments_col.count_documents({"status": "pending"})
    await message.reply(
        f"📊 **Bot Statistics**\n"
        f"{'─'*28}\n"
        f"👥 Users: **{u}** | 🏘 Groups: **{g}**\n"
        f"💎 Premium: **{p}** | 🚫 Banned: **{b}**\n"
        f"📩 Requests: **{r}** | 🔗 Refers: **{total_refers}**\n"
        f"💰 Pending Payments: **{pending_pay}**\n"
        f"{'─'*28}\n"
        f"🕐 {now_ist().strftime('%d %b %Y %H:%M')} IST",
        reply_markup=InlineKeyboardMarkup([
            [
                InlineKeyboardButton("💰 Pending Payments", callback_data="admin_pending_pay"),
                InlineKeyboardButton("📩 Requests", callback_data="admin_view_requests"),
            ],
            [
                InlineKeyboardButton("🚫 Banned Users Clear", callback_data="admin_clear_banned"),
                InlineKeyboardButton("📩 Requests Clear", callback_data="admin_clear_requests"),
            ],
            [
                InlineKeyboardButton("💰 Payments Clear", callback_data="admin_clear_payments"),
                InlineKeyboardButton("🔄 Refresh", callback_data="admin_refresh_stats"),
            ],
        ])
    )

def _build_global_settings_kb(s):
    """Global settings inline keyboard — toggle buttons"""
    def tog(val): return "✅ ON" if val else "❌ OFF"
    return InlineKeyboardMarkup([
        [
            InlineKeyboardButton(f"🔧 Maintenance: {tog(s.get('maintenance'))}", callback_data="gs_global_maintenance"),
            InlineKeyboardButton(f"🔗 Shortlink: {tog(s.get('shortlink_enabled',True))}", callback_data="gs_global_shortlink"),
        ],
        [
            InlineKeyboardButton(f"📢 Force Sub: {tog(s.get('force_sub',True))}", callback_data="gs_global_forcesub"),
            InlineKeyboardButton(f"🎬 IMDB Info: {tog(s.get('tmdb_enabled',True))}", callback_data="gs_global_tmdb"),
        ],
        [
            InlineKeyboardButton(f"🛡 Link Protect: {tog(s.get('link_protection',True))}", callback_data="gs_global_linkprotect"),
            InlineKeyboardButton(f"🗑 Auto Delete: {tog(s.get('auto_delete',True))}", callback_data="gs_global_autodelete"),
        ],
        [
            InlineKeyboardButton(f"⏱ {s.get('auto_delete_time',300)//60} min", callback_data="gs_global_deletetime"),
            InlineKeyboardButton(f"📊 Daily Limit: {s.get('daily_limit',10)}", callback_data="gs_global_dailylimit"),
        ],
        [
            InlineKeyboardButton(f"🆓 Free: {s.get('free_results',5)} res", callback_data="gs_global_freeresults"),
            InlineKeyboardButton(f"💎 Prem: {s.get('premium_results',10)} res", callback_data="gs_global_premresults"),
        ],
        [InlineKeyboardButton("🔄 Refresh", callback_data="gs_global_refresh")],
    ])

@bot.on_message(filters.command("settings") & filters.user(ADMINS))
async def show_settings(client, message: Message):
    s = await get_settings()
    kb = _build_global_settings_kb(s)
    await message.reply(
        f"⚙️ **Global Bot Settings**\n"
        f"{'─'*28}\n"
        f"🔗 Shortlink: {'✅ ON' if s.get('shortlink_enabled', True) else '❌ OFF'}\n"
        f"🎬 IMDB Info: {'✅ ON' if s.get('tmdb_enabled', True) else '❌ OFF'}\n"
        f"📢 Force Sub: {'✅ ON' if s.get('force_sub', True) else '❌ OFF'}\n"
        f"🔧 Maintenance: {'✅ ON' if s.get('maintenance') else '❌ OFF'}\n"
        f"{'─'*28}\n"
        f"Button dabao — toggle ho jaayegi!",
        reply_markup=kb
    )

@bot.on_message(filters.command("ping") & filters.user(ADMINS))
async def ping(client, message: Message):
    t = time.time()
    m = await message.reply("🏓")
    ms = round((time.time() - t) * 1000)
    sys_txt = ""
    if HAS_PSUTIL:
        try:
            cpu = psutil.cpu_percent(interval=0.1)
            ram = psutil.virtual_memory()
            sys_txt = f"\n🖥 CPU: {cpu}% | 💾 RAM: {ram.percent}%"
        except: pass
    await m.edit(f"🏓 Pong! {ms}ms{sys_txt}")

@bot.on_message(filters.command("premium"))
async def premium_info(client, message: Message):
    uid = message.from_user.id
    prem = await is_premium(uid)
    exp = await get_premium_expiry(uid)
    exp_str = exp.astimezone(IST).strftime("%d %b %Y") if exp else None
    miniapp_url = _miniapp_url(uid, getattr(message.from_user,'first_name',None) or 'User')
    if prem:
        text = (f"💎 **Premium Active!**\n"
                f"Expiry: **{exp_str}**\n\n"
                f"✅ No ad verify\n✅ Unlimited downloads\n✅ HD Stream + Download")
    else:
        text = ("💎 **Premium Lo — Sab Milega!**\n\n"
                "✅ No ad/verify\n✅ Unlimited downloads\n"
                "✅ HD Stream + Download\n\n"
                "**Plans:** ₹99/7d | ₹199/30d | ₹499/90d\n"
                "**FREE:** 10 refer karo → 15 din premium!")
    buttons = []
    if miniapp_url:
        buttons.append([InlineKeyboardButton("💎 Plans Dekho", web_app=WebAppInfo(url=miniapp_url))])
    await message.reply(text, reply_markup=InlineKeyboardMarkup(buttons) if buttons else None)

@bot.on_message(filters.command("mystats"))
async def mystats(client, message: Message):
    uid = message.from_user.id
    prem = await is_premium(uid)
    count = await get_daily_count(uid)
    doc = await users_col.find_one({"user_id": uid})
    joined = make_aware(doc["joined"]).astimezone(IST).strftime("%d %b %Y") if doc and doc.get("joined") else "N/A"
    refers = doc.get("refer_count", 0) if doc else 0
    s = await get_settings()
    limit = "∞" if prem else str(s.get("daily_limit", 10))
    exp = await get_premium_expiry(uid)
    exp_str = exp.astimezone(IST).strftime("%d %b %Y") if exp else "N/A"
    await message.reply(
        f"📊 **{message.from_user.first_name} ki Stats**\n\n"
        f"`{uid}` | Joined: {joined}\n"
        f"💎 Premium: {'✅ ' + exp_str if prem else '❌ Nahi'}\n"
        f"📥 Aaj: {count}/{limit} | 🔗 Refers: {refers}\n\n"
        f"{'🏆 Boss ho tum!' if prem else '💡 10 refer karo → FREE premium!'}",
        reply_markup=InlineKeyboardMarkup([[
            InlineKeyboardButton("💎 Premium Lo", callback_data="show_premium"),
            InlineKeyboardButton("🔗 Refer Link", callback_data="refer_info")
        ]])
    )

@bot.on_message(filters.command("help"))
async def help_cmd(client, message: Message):
    uid = message.from_user.id
    prem = await is_premium(uid)
    await message.reply(
        f"❓ **Help — {message.from_user.first_name}**\n\n"
        f"**Kaise use karo:**\n"
        f"1️⃣ Channel join karo (mandatory)\n"
        f"2️⃣ Group mein movie naam type karo\n"
        f"3️⃣ File ka button dabao\n"
        f"4️⃣ {'Seedha PM mein file! 🎉' if prem else 'Ek ad dekho → file PM mein! 📥'}\n\n"
        f"💎 **Premium** = No ad, unlimited, HD stream\n"
        f"🎁 **10 Refer** = 15 din FREE Premium\n\n"
        f"/premium | /mystats | /referlink",
        reply_markup=InlineKeyboardMarkup([
            [InlineKeyboardButton("🆘 Support", url=SUPPORT_LINK)],
            [InlineKeyboardButton("💎 Premium Lo", callback_data="show_premium")]
        ])
    )

@bot.on_message(filters.command("request"))
async def file_request(client, message: Message):
    args = message.command
    if len(args) < 2: await message.reply("Usage: `/request Movie Name`"); return
    req_text = " ".join(args[1:])
    uid = message.from_user.id
    await requests_col.insert_one({"user_id": uid, "name": message.from_user.first_name, "request": req_text, "chat_id": message.chat.id, "time": now()})
    msg = await message.reply(f"📩 **Request Submit!**\n\n📁 `{req_text}`\n\n⏳ Owner review karega!")
    if message.chat.type != enums.ChatType.PRIVATE:
        asyncio.create_task(del_later(msg, 300))
    await send_log(
        f"📩 #NewRequest\n👤 {message.from_user.mention} (`{uid}`)\n📁 `{req_text}`",
        reply_markup=InlineKeyboardMarkup([[
            InlineKeyboardButton("✅ Done", callback_data=f"req_done_{uid}_{req_text[:20]}"),
            InlineKeyboardButton("❌ Skip", callback_data=f"req_skip_{uid}"),
        ]])
    )


# ═══════════════════════════════════════
#  _process_streamlink — CORE FUNCTION
#  Video message leke stream + download link banata hai
# ═══════════════════════════════════════
async def _process_streamlink(client, orig_msg: Message, media_msg: Message, uid: int):
    """
    Video/document message se stream link banao.
    - media_msg: woh message jisme video hai
    - orig_msg:  jahan reply karna hai
    """
    try:
        wait = await orig_msg.reply(
            "⚡ **Stream Link Ban Raha Hai...**\n"
            "🔄 _File process ho rahi hai..._"
        )

        # Step 1: File FILE_CHANNEL mein copy karo fresh file_id ke liye
        try:
            if media_msg.video or media_msg.document or media_msg.audio:
                forwarded = await media_msg.copy(FILE_CHANNEL)
                msg_id = forwarded.id
            else:
                await wait.edit("❌ **Valid video/document nahi hai!**")
                return
        except Exception as e:
            logger.error(f"_process_streamlink forward error uid={uid}: {e}")
            await wait.edit(f"❌ **Error:** `{e}`\n\nBot ke paas FILE_CHANNEL access chahiye.")
            return

        # Step 2: URLs banao
        if not KOYEB_URL:
            await wait.edit(
                "⚠️ **KOYEB_URL config mein set nahi hai!**\n\n"
                "Admin se contact karo — stream server configure nahi hua."
            )
            return

        base = KOYEB_URL.rstrip("/")
        stream_url   = f"{base}/?uid={uid}&mid={msg_id}"
        download_url = f"{base}/download/{msg_id}?uid={uid}"
        player_url   = f"{base}/stream_file/{msg_id}?uid={uid}"

        # Step 3: File info
        fname = get_file_name(media_msg) or "video"
        fsize = get_file_size(media_msg) or ""

        # Step 4: Result bhejo
        kb = InlineKeyboardMarkup([
            [
                InlineKeyboardButton("▶️ Stream (WebApp)", web_app=WebAppInfo(url=stream_url)),
            ],
            [
                InlineKeyboardButton("⬇️ Download", url=download_url),
                InlineKeyboardButton("🔗 Direct Link", url=player_url),
            ]
        ])

        await wait.edit(
            f"✅ **Stream Link Ready!**\n\n"
            f"📁 **File:** `{fname}`\n"
            f"{'📦 **Size:** ' + fsize + chr(10) if fsize else ''}"
            f"\n"
            f"▶️ **Stream URL:**\n`{stream_url}`\n\n"
            f"⬇️ **Download URL:**\n`{download_url}`\n\n"
            f"⚠️ _Link 60 min tak valid hai. Share mat karo._",
            reply_markup=kb
        )
        logger.info(f"✅ Stream link generated uid={uid} msg_id={msg_id}")

    except FloodWait as e:
        await asyncio.sleep(e.value)
        logger.warning(f"_process_streamlink FloodWait {e.value}s")
    except Exception as e:
        logger.error(f"_process_streamlink error uid={uid}: {e}")
        try:
            await orig_msg.reply(f"❌ **Stream link banana failed!**\n`{e}`")
        except: pass


# ═══════════════════════════════════════
#  STREAMLINK COMMAND
#  /streamlink — video bhejo → stream link milega
# ═══════════════════════════════════════
@bot.on_message(filters.command("streamlink") & filters.private)
async def streamlink_cmd(client, message: Message):
    """💎 PREMIUM ONLY — Video stream link generator."""
    try:
        uid = message.from_user.id
        logger.info(f"🔗 /streamlink uid={uid}")

        if not await is_premium(uid):
            await message.reply(
                "💎 **StreamLink — Premium Feature!**\n\n"
                "Trial expire ho gaya ya premium nahi liya.\n\n"
                "Premium lo aur unlock karo:\n"
                "🔗 Kisi bhi video ka stream link\n"
                "⚡ Bina ads ke instant delivery",
                reply_markup=InlineKeyboardMarkup([[
                    InlineKeyboardButton("💎 Premium Plans", callback_data="show_premium")
                ]])
            )
            return

        # Case 1: Reply to video
        if message.reply_to_message:
            rmsg = message.reply_to_message
            if rmsg.video or rmsg.document or rmsg.audio:
                await _process_streamlink(client, message, rmsg, uid)
                return

        # Case 2: Ask to send video
        _streamlink_waiting[uid] = True
        wait_msg = await message.reply(
            "📤 **Stream Link Generator**\n\n"
            "Ab koi bhi video file bhejo — stream link ban jaayega!\n\n"
            "💡 Ya kisi video pe reply karke `/streamlink` use karo\n"
            "⏱ 2 minutes mein bhejni hai",
            reply_markup=InlineKeyboardMarkup([[
                InlineKeyboardButton("❌ Cancel", callback_data="streamlink_cancel")
            ]])
        )
        logger.info(f"🔗 Waiting for video from uid={uid}")

        async def _cancel_wait():
            await asyncio.sleep(120)
            if _streamlink_waiting.get(uid):
                _streamlink_waiting.pop(uid, None)
                try: await wait_msg.edit("⏰ Time out! Phir se `/streamlink` try karo.")
                except: pass
        asyncio.create_task(_cancel_wait())

    except Exception as ex:
        logger.error(f"streamlink_cmd error uid={getattr(message.from_user,'id',0)}: {ex}")
        try: await message.reply(f"❌ Error: `{ex}`")
        except: pass


@bot.on_message(filters.private & (filters.video | filters.document | filters.audio), group=2)
async def handle_streamlink_video(client, message: Message):
    """Video aaya — process if user was waiting for streamlink."""
    try:
        uid = message.from_user.id if message.from_user else None
        if not uid: return
        if _streamlink_waiting.get(uid):
            _streamlink_waiting.pop(uid, None)
            await _process_streamlink(client, message, message, uid)
    except Exception as ex:
        logger.error(f"handle_streamlink_video error: {ex}")


# ═══════════════════════════════════════
#  PREMIUM EXPIRY NOTIFICATION
#  Daily check — 3 din pehle warn karo
# ═══════════════════════════════════════
async def _send_premium_expiry_reminders():
    """Daily job — premium expire hone wale users ko notify karo."""
    try:
        from datetime import timedelta
        now_dt = now()
        # Users jinke premium 3 din mein expire honge
        three_days_later = now_dt + timedelta(days=3)
        async for doc in premium_col.find({
            "expiry": {"$gt": now_dt, "$lte": three_days_later},
            "expiry_warned": {"$ne": True}
        }):
            uid = doc.get("user_id")
            exp = doc.get("expiry")
            if not uid or not exp: continue
            days_left = max(0, (exp - now_dt).days)
            try:
                await bot.send_message(
                    uid,
                    f"⚠️ **Premium Expiry Reminder!**\n\n"
                    f"Aapka Premium plan **{days_left} din** mein expire ho raha hai!\n\n"
                    f"📅 Expiry: `{exp.strftime('%d %b %Y')}`\n\n"
                    f"Renew karo aur uninterrupted access enjoy karo! 💎",
                    reply_markup=InlineKeyboardMarkup([[
                        InlineKeyboardButton("💎 Renew Premium", callback_data="show_premium")
                    ]])
                )
                # Mark as warned
                await premium_col.update_one(
                    {"user_id": uid},
                    {"$set": {"expiry_warned": True}}
                )
                await asyncio.sleep(0.1)
            except Exception as e:
                logger.warning(f"Premium expiry remind failed {uid}: {e}")
        logger.info("✅ Premium expiry reminders sent")
    except Exception as e:
        logger.error(f"Premium expiry reminder job error: {e}")

# Keep remaining admin commands: broadcast, shortlinks, fsub, gshortlink, setcommands, admin panel, etc
# (These are the same as original — too long to duplicate, only the fixes above matter)

# ═══════════════════════════════════════
#  FIX: ALL MISSING ADMIN COMMANDS
# ═══════════════════════════════════════

@bot.on_message(filters.command("setdelete") & filters.user(ADMINS))
async def setdelete_cmd(client, message: Message):
    """
    Usage:
    /setdelete 300       → 5 min set karo
    /setdelete on        → auto delete ON
    /setdelete off       → auto delete OFF
    """
    args = message.command
    if len(args) < 2:
        await message.reply(
            "⚙️ **Auto Delete Settings**\n\n"
            "`/setdelete on` — Auto delete ON\n"
            "`/setdelete off` — Auto delete OFF\n"
            "`/setdelete 300` — 5 min (seconds mein)\n"
            "`/setdelete 600` — 10 min\n\n"
            "**Common values:**\n"
            "• 60 = 1 min | 180 = 3 min\n"
            "• 300 = 5 min | 600 = 10 min"
        ); return
    val = args[1].lower()
    if val == "on":
        await update_setting("auto_delete", True)
        await message.reply("✅ Auto Delete: **ON**")
    elif val == "off":
        await update_setting("auto_delete", False)
        await message.reply("✅ Auto Delete: **OFF**")
    else:
        try:
            secs = int(val)
            if secs < 30: await message.reply("❌ Minimum 30 seconds!"); return
            await update_setting("auto_delete_time", secs)
            await update_setting("auto_delete", True)
            await message.reply(f"✅ Auto Delete: **{secs} sec ({secs//60} min)**")
        except:
            await message.reply("❌ `/setdelete on/off/<seconds>`")


@bot.on_message(filters.command("setlimit") & filters.user(ADMINS))
async def setlimit_cmd(client, message: Message):
    """
    Usage: /setlimit 10
    Free users ke liye daily download limit set karo.
    """
    args = message.command
    if len(args) < 2:
        s = await get_settings()
        cur = s.get("daily_limit", 10)
        await message.reply(
            f"📊 **Daily Limit Settings**\n\n"
            f"Current limit: **{cur}** files/din\n\n"
            f"Usage: `/setlimit <number>`\n"
            f"Example: `/setlimit 10`\n\n"
            f"• 0 = Unlimited (free users ke liye)\n"
            f"• Premium users = Always unlimited"
        ); return
    try:
        n = int(args[1])
        await update_setting("daily_limit", n)
        await message.reply(f"✅ Daily Limit: **{n}** {'(Unlimited)' if n == 0 else f'files/din'}")
    except:
        await message.reply("❌ `/setlimit <number>` — Number chahiye")


@bot.on_message(filters.command("setresults") & filters.user(ADMINS))
async def setresults_cmd(client, message: Message):
    """
    Usage: /setresults <free> <premium>
    Search results count set karo.
    """
    args = message.command
    if len(args) < 3:
        s = await get_settings()
        await message.reply(
            f"🔢 **Results Count Settings**\n\n"
            f"Free results: **{s.get('free_results', 5)}**\n"
            f"Premium results: **{s.get('premium_results', 10)}**\n\n"
            f"Usage: `/setresults <free> <premium>`\n"
            f"Example: `/setresults 5 10`"
        ); return
    try:
        free = int(args[1]); prem = int(args[2])
        await update_setting("free_results", free)
        await update_setting("premium_results", prem)
        await message.reply(f"✅ Results — Free: **{free}** | Premium: **{prem}**")
    except:
        await message.reply("❌ `/setresults <free_count> <premium_count>`")


@bot.on_message(filters.command("maintenance") & filters.user(ADMINS))
async def maintenance_cmd(client, message: Message):
    """
    Usage: /maintenance on/off
    Maintenance mode toggle — sirf admins use kar payenge.
    """
    args = message.command
    if len(args) < 2:
        s = await get_settings()
        cur = s.get("maintenance", False)
        await message.reply(
            f"🔧 **Maintenance Mode**\n\n"
            f"Current: **{'ON ✅' if cur else 'OFF ❌'}**\n\n"
            f"Usage: `/maintenance on` ya `/maintenance off`\n\n"
            f"ON hone par normal users bot use nahi kar sakte."
        ); return
    val = args[1].lower()
    if val in ["on", "1", "true"]:
        await update_setting("maintenance", True)
        await message.reply("🔧 Maintenance: **ON** ✅\n\nAb sirf admins bot use kar sakte hain.")
    elif val in ["off", "0", "false"]:
        await update_setting("maintenance", False)
        await message.reply("✅ Maintenance: **OFF**\n\nBot sab ke liye available hai!")
    else:
        await message.reply("❌ `/maintenance on` ya `/maintenance off`")


@bot.on_message(filters.command("resetsettings") & filters.user(ADMINS) & filters.private)
async def reset_settings_cmd(client, message: Message):
    """
    /resetsettings — Saari settings DEFAULT pe reset karo
    Sirf OWNER use kar sakta hai — confirm karna padega
    """
    args = message.command
    # Confirmation required — /resetsettings confirm
    if len(args) < 2 or args[1].lower() != "confirm":
        await message.reply(
            "⚠️ **Settings Reset**\n\n"
            "Yeh sari bot settings **DEFAULT** pe reset kar dega!\n\n"
            "**Kya reset hoga:**\n"
            "• Force sub channels\n"
            "• Shortlink settings\n"
            "• Auto delete settings\n"
            "• Daily limit\n"
            "• Aur sab kuch\n\n"
            "**Confirm karne ke liye:**\n"
            "`/resetsettings confirm`"
        )
        return

    try:
        # MongoDB se purani settings delete karo
        await settings_col.delete_one({"_id": "global"})
        # Naya DEFAULT_SETTINGS insert karo
        await settings_col.insert_one({"_id": "global", **DEFAULT_SETTINGS})
        await message.reply(
            "✅ **Settings Reset Ho Gayi!**\n\n"
            "Saari settings default pe aa gayi hain.\n\n"
            "**Ab force sub channels:**\n"
            "• AsBhai Channel (`-1002283182645`)\n"
            "• Latest Movies (`-1002892671107`)\n\n"
            "Bot restart karne ki zaroorat nahi! ✅"
        )
    except Exception as e:
        await message.reply(f"❌ Reset fail hua!\nError: `{e}`")


@bot.on_message(filters.command(["forcesub", "fsub"]) & filters.user(ADMINS))
async def forcesub_cmd(client, message: Message):
    args = message.command
    s = await get_settings()
    cur = s.get("force_sub", True)
    channels = s.get("fsub_channels", [])

    if len(args) < 2:
        # Show full status
        text = (
            f"📢 **Force Subscribe Manager**\n\n"
            f"**Status:** {'🟢 ON ✅' if cur else '🔴 OFF ❌'}\n\n"
        )
        if channels:
            text += f"**Channels ({len(channels)}):**\n"
            for i, ch in enumerate(channels, 1):
                cid = ch.get('id', '?')
                ctitle = ch.get('title', 'Channel')
                cuname = ch.get('username', '')
                req_only = ch.get('req_only', False)
                mode_icon = "📨" if req_only else "📢"
                text += f"`{i}.` {mode_icon} **{ctitle}**\n"
                text += f"    ID: `{cid}`"
                if cuname:
                    text += f" | @{cuname}"
                if req_only:
                    text += " | `[Request-only]`"
                text += "\n"
        else:
            text += "⚠️ **Koi channel nahi!** Pehle channel add karo.\n"

        text += (
            f"\n**Commands:**\n"
            f"`/fsub on` — Force sub ON karo\n"
            f"`/fsub off` — Force sub OFF karo\n"
            f"`/fsub add @username` — Channel add karo (join type)\n"
            f"`/fsub add -100xxx Title` — ID se add karo\n"
            f"`/fsub add -100xxx Title req` — Request-only channel add karo 📨\n"
            f"`/fsub remove 1` — Number se remove karo\n"
            f"`/fsub remove @username` — Username se remove karo\n"
        )
        await message.reply(text)
        return

    action = args[1].lower()

    # ON/OFF
    if action in ["on", "1", "enable"]:
        await update_setting("force_sub", True)
        await message.reply("📢 Force Subscribe: **ON** ✅")
        return
    elif action in ["off", "0", "disable"]:
        await update_setting("force_sub", False)
        await message.reply("✅ Force Subscribe: **OFF** ❌")
        return

    # ADD
    elif action in ["add", "+"]:
        if len(args) < 3:
            await message.reply("❌ Usage: `/fsub add @username` ya `/fsub add -100xxx Title`\n\n💡 Request-only channel ke liye: `/fsub add -100xxx Title req`")
            return
        ch_input = args[2].strip()
        # ✅ FIX: req_only support — last arg 'req' hoga to request-only channel
        remaining_args = args[3:] if len(args) > 3 else []
        req_only = False
        if remaining_args and remaining_args[-1].lower() == "req":
            req_only = True
            remaining_args = remaining_args[:-1]
        custom_title = " ".join(remaining_args) if remaining_args else None
        try:
            chat = await client.get_chat(ch_input)
            ch_id = chat.id
            ch_title = custom_title or chat.title or ch_input
            ch_username = chat.username or ""
        except Exception:
            try:
                ch_id = int(ch_input)
                ch_title = custom_title or f"Channel {ch_id}"
                ch_username = ""
            except ValueError:
                await message.reply(f"❌ Invalid: `{ch_input}`\n\nBot us channel ka admin hona chahiye!")
                return

        existing_ids = [c.get("id") for c in channels]
        if ch_id in existing_ids:
            await message.reply(f"⚠️ **{ch_title}** already list mein hai!")
            return

        channels.append({"id": ch_id, "title": ch_title, "username": ch_username, "req_only": req_only})
        await update_setting("fsub_channels", channels)
        mode_txt = "📨 Request-only (users sirf request bhejenge, join nahi karenge)" if req_only else "📢 Join channel"
        await message.reply(
            f"✅ **{ch_title}** add ho gaya!\n"
            f"ID: `{ch_id}`\n"
            f"Mode: {mode_txt}\n"
            f"Total: **{len(channels)} channels**\n\n"
            f"⚠️ _Bot ko us channel ka admin banana zaruri hai!_\n"
            f"💡 Mode change karne ke liye remove karke dobara add karo with/without `req`"
        )
        return

    # REMOVE
    elif action in ["remove", "del", "-"]:
        if len(args) < 3:
            if not channels:
                await message.reply("📢 Koi channel nahi hai.")
                return
            text = "📢 **Force Sub Channels:**\n\n"
            for i, ch in enumerate(channels, 1):
                text += f"`{i}.` {ch.get('title','?')} — `{ch.get('id','?')}`\n"
            text += "\nRemove: `/fsub remove 1` ya `/fsub remove @username`"
            await message.reply(text)
            return

        ch_input = args[2].strip()
        new_channels = []
        removed = None

        # Number se remove
        try:
            idx = int(ch_input) - 1
            if 0 <= idx < len(channels):
                removed = channels[idx]
                new_channels = [c for j, c in enumerate(channels) if j != idx]
            else:
                await message.reply(f"❌ Invalid number. 1 to {len(channels)} use karo.")
                return
        except ValueError:
            # Username/ID se remove
            for ch in channels:
                if (str(ch.get("id")) == str(ch_input) or
                    ch.get("username", "").lstrip("@") == ch_input.lstrip("@")):
                    removed = ch
                else:
                    new_channels.append(ch)

        if removed:
            await update_setting("fsub_channels", new_channels)
            await message.reply(
                f"✅ **{removed.get('title', 'Channel')}** remove ho gaya!\n"
                f"Remaining: **{len(new_channels)} channels**"
            )
        else:
            await message.reply(f"❌ `{ch_input}` list mein nahi mila.")
        return

    else:
        await message.reply(
            "❌ Invalid action!\n\n"
            "`/fsub` — Status dekho\n"
            "`/fsub on/off` — Toggle\n"
            "`/fsub add @username` — Add\n"
            "`/fsub remove 1` — Remove"
        )


@bot.on_message(filters.command("addforcechannel") & filters.user(ADMINS))
async def add_force_channel_cmd(client, message: Message):
    """Redirect to /fsub add"""
    args = message.command
    if len(args) < 2:
        await message.reply("💡 Ab `/fsub add @username` use karo!\n\nExample: `/fsub add @mychannel`")
        return
    # Forward to fsub add
    message.command = ["fsub", "add"] + args[1:]
    await forcesub_cmd(client, message)


@bot.on_message(filters.command("removeforcechannel") & filters.user(ADMINS))
async def remove_force_channel_cmd(client, message: Message):
    """Redirect to /fsub remove"""
    args = message.command
    if len(args) < 2:
        await message.reply("💡 Ab `/fsub remove <number>` use karo!\n\n`/fsub` type karo channels dekhne ke liye.")
        return
    message.command = ["fsub", "remove"] + args[1:]
    await forcesub_cmd(client, message)


@bot.on_message(filters.command("removeshortlink") & filters.user(ADMINS))
async def remove_shortlink_cmd(client, message: Message):
    """
    Usage: /removeshortlink <number>
    Shortlink list mein se hatao.
    """
    links = []
    async for doc in shortlinks_col.find({}).sort("order", 1):
        links.append(doc)

    args = message.command
    if len(args) < 2:
        if not links:
            await message.reply("📭 Koi shortlink nahi.\n`/addshortlink` se add karo."); return
        text = "🔗 **Shortlinks — Hatane ke liye number likho:**\n\n"
        for i, sl in enumerate(links, 1):
            text += f"`{i}.` {'✅' if sl.get('active') else '❌'} **{sl.get('label','?')}** — {sl.get('url','?')}\n"
        text += "\nUsage: `/removeshortlink 1`"
        await message.reply(text); return

    try:
        idx = int(args[1]) - 1
        if idx < 0 or idx >= len(links):
            await message.reply(f"❌ Number 1 se {len(links)} ke beech hona chahiye!"); return
        sl = links[idx]
        await shortlinks_col.delete_one({"_id": sl["_id"]})
        await message.reply(f"✅ Shortlink **{sl.get('label','?')}** hata diya!")
    except:
        await message.reply("❌ `/removeshortlink <number>` — Pehle `/removeshortlink` likho list dekhne ke liye")


@bot.on_message(filters.command("notify") & filters.user(ADMINS))
async def notify_cmd(client, message: Message):
    """
    Usage: /notify <user_id> <message>
    Kisi specific user ko message bhejo.
    """
    args = message.command
    reply_msg = message.reply_to_message
    if len(args) < 2:
        await message.reply(
            "🔔 **Notify Command**\n\n"
            "`/notify <user_id> <message>` — User ko message bhejo\n"
            "Ya kisi message ko reply karke:\n"
            "`/notify <user_id>` — Reply wala message forward karo\n\n"
            "Example: `/notify 123456789 Aapki file ready hai!`"
        ); return
    try:
        target_uid = int(args[1])
        if len(args) > 2:
            text = " ".join(args[2:])
            await client.send_message(target_uid, f"🔔 **Owner ka message:**\n\n{text}")
        elif reply_msg:
            await reply_msg.copy(chat_id=target_uid)
        else:
            await message.reply("❌ Ya text likho ya kisi message ko reply karke notify karo!"); return
        await message.reply(f"✅ `{target_uid}` ko message bhej diya!")
    except PeerIdInvalid:
        await message.reply(f"❌ User `{args[1]}` nahi mila. User ne bot start kiya hoga?")
    except UserIsBlocked:
        await message.reply(f"❌ User ne bot block kar rakha hai.")
    except Exception as e:
        await message.reply(f"❌ Error: {e}")


@bot.on_message(filters.command("addshortlink") & filters.user(ADMINS))
async def add_shortlink_cmd(client, message: Message):
    args = message.command
    if len(args) < 4:
        await message.reply("`/addshortlink <api_key> <url> <hours> [label]`"); return
    api_key = args[1]
    api_url = args[2].strip("/").replace("https://","").replace("http://","")
    try: hours = int(args[3])
    except: await message.reply("❌ Hours number hona chahiye"); return
    label = " ".join(args[4:]) if len(args) > 4 else api_url
    count = await shortlinks_col.count_documents({})
    await shortlinks_col.insert_one({"api_key": api_key, "url": api_url, "hours": hours, "label": label, "active": True, "order": count + 1, "added_at": now()})
    test = await make_shortlink_with("https://t.me/test", api_key, api_url)
    await message.reply(f"✅ Shortlink Add!\n🏷 {label}\n🌐 `{api_url}`\n⏰ {hours}h\n🧪 {'✅ OK' if test != 'https://t.me/test' else '⚠️ Fail'}")
    await send_log(f"🔗 #ShortlinkAdded\n{label} | `{api_url}` | {hours}h")

@bot.on_message(filters.command("shortlinks") & filters.user(ADMINS))
async def list_shortlinks_cmd(client, message: Message):
    links = []
    async for doc in shortlinks_col.find({}).sort("order", 1): links.append(doc)
    if not links: await message.reply("📭 Koi shortlink nahi.\n`/addshortlink <api> <url> <hours> [label]`"); return
    text = f"🔗 **Shortlinks ({len(links)})**\n\n"
    for i, sl in enumerate(links):
        text += f"{'✅' if sl.get('active') else '❌'} {i+1}. **{sl.get('label')}** | ⏰ {sl.get('hours',24)}h\n"
    await message.reply(text)

# ═══════════════════════════════════════
#  BLOGGER POSTS MANAGEMENT
@bot.on_message(filters.command("addblog") & filters.user(ADMINS))
async def addblog_cmd(client, message: Message):
    """Blogger system hata diya gaya hai"""
    await message.reply(
        "ℹ️ **Blogger system is bot se hata diya gaya hai.**\n\n"
        "Shortlink use karo: `/addshortlink <api_key> <url> <hours> [label]`"
    )


@bot.on_message(filters.command("removeblog") & filters.user(ADMINS))
async def removeblog_cmd(client, message: Message):
    """Blogger system hata diya gaya hai"""
    await message.reply(
        "ℹ️ **Blogger system is bot se hata diya gaya hai.**\n\n"
        "Shortlink manage karo: `/shortlinks` | `/removeshortlink <number>`"
    )


@bot.on_message(filters.command("blogposts") & filters.user(ADMINS))
async def blogposts_cmd(client, message: Message):
    """Blogger system hata diya gaya hai — shortlinks dikhao"""
    links = []
    async for doc in shortlinks_col.find({}).sort("order", 1):
        links.append(doc)
    if not links:
        await message.reply(
            "📭 Koi shortlink nahi hai.\n\n"
            "Add karo: `/addshortlink <api_key> <url> <hours> [label]`"
        )
        return
    text = f"🔗 **Active Shortlinks ({len(links)}):**\n\n"
    for i, sl in enumerate(links, 1):
        text += f"{'✅' if sl.get('active') else '❌'} **{i}. {sl.get('label','?')}** | ⏰ {sl.get('hours',24)}h\n"
    text += "\n`/shortlinks` | `/removeshortlink <n>` | `/addshortlink ...`"
    await message.reply(text)


@bot.on_message(filters.command("syncsheet") & filters.user(ADMINS))
async def syncsheet_cmd(client, message: Message):
    """/syncsheet — Blogger system hataya gaya hai"""
    await message.reply(
        "ℹ️ **Blogger system is bot se hata diya gaya hai.**\n\n"
        "Sirf Shortlink system use hota hai.\n"
        "Shortlink manage karo: `/shortlinks` | `/addshortlink` | `/removeshortlink`"
    )


async def group_shortlink_add(client, message: Message):
    if not message.chat or message.chat.type == enums.ChatType.PRIVATE:
        await message.reply("❌ Group mein use karo!"); return
    uid = message.from_user.id; chat_id = message.chat.id
    try:
        member = await client.get_chat_member(chat_id, uid)
        is_admin = member.status in [enums.ChatMemberStatus.OWNER, enums.ChatMemberStatus.ADMINISTRATOR] or uid in ADMINS
    except: is_admin = uid in ADMINS
    if not is_admin: await message.reply("❌ Sirf admins!"); return

    # Group premium check
    async def is_group_premium(cid):
        doc = await group_prem_col.find_one({"chat_id": cid, "status": "approved"})
        if not doc: return False
        expiry = make_aware(doc.get("expiry"))
        if expiry and now() > expiry:
            await group_prem_col.update_one({"chat_id": cid}, {"$set": {"status": "expired"}})
            return False
        return True

    if not await is_group_premium(chat_id) and uid not in ADMINS:
        await message.reply("❌ Group Premium chahiye!\n💰 ₹300/mahina | Mini App se lo."); return

    args = message.command
    if len(args) < 3: await message.reply("`/gshortlink <api_key> <url> [hours] [label]`"); return
    api_key = args[1]; api_url = args[2].strip("/").replace("https://","").replace("http://","")
    try: hours = int(args[3]) if len(args) > 3 else 24
    except: hours = 24
    label = " ".join(args[4:]) if len(args) > 4 else api_url
    count = await group_sl_col.count_documents({"chat_id": chat_id})
    await group_sl_col.insert_one({"chat_id": chat_id, "api_key": api_key, "url": api_url, "hours": hours, "label": label, "active": True, "order": count + 1, "added_by": uid, "added_at": now()})
    test = await make_shortlink_with("https://t.me/test", api_key, api_url)
    await message.reply(f"✅ Group Shortlink Add!\n🏷 {label}\n🌐 `{api_url}`\n⏰ {hours}h\n🧪 {'✅ OK' if test != 'https://t.me/test' else '⚠️ Fail'}")
    await send_log(f"🔗 #GroupShortlink\n🏘 {message.chat.title} (`{chat_id}`)\n{label} | `{api_url}` | {hours}h | by `{uid}`")

@bot.on_message(filters.command("broadcast") & filters.user(ADMINS) & filters.private)
async def broadcast(client, message: Message):
    args = message.command
    reply_msg = message.reply_to_message

    if len(args) < 2:
        await message.reply(
            "📡 **Broadcast Usage:**\n\n"
            "`/broadcast users <text>` — Sirf users\n"
            "`/broadcast groups <text>` — Sirf groups\n"
            "`/broadcast all <text>` — Sabko\n\n"
            "**Ya kisi message ko reply karke:**\n"
            "`/broadcast users` — reply wala message bhejo\n"
            "`/broadcast all` — reply wala message sabko"
        )
        return

    target = args[1].lower()
    if target not in ["users", "groups", "all"]:
        await message.reply("❌ Target: `users` / `groups` / `all`"); return

    text = " ".join(args[2:]) if len(args) > 2 else ""
    if not text and not reply_msg:
        await message.reply("❌ Ya text likho ya kisi message ko reply karke broadcast karo!"); return

    # ✅ FIX: Ek time pe sirf ek broadcast — duplicate broadcast block karo
    if _broadcast_lock.locked():
        await message.reply("⚠️ **Broadcast pehle se chal raha hai!**\nPehla wala khatam hone do.")
        return

    async with _broadcast_lock:
     sm = await message.reply(f"📡 **Broadcast shuru!** Target: `{target}`\n⏳ Please wait...")
     total = done = failed = blocked = 0
     start_time = time.time()

     # ✅ FIX: Deduplicate — ek user ko sirf ek baar message jaye
     sent_ids = set()

     async def _send_one(dest_id):
        nonlocal done, failed, blocked
        if dest_id in sent_ids:
            return  # Already sent — skip!
        sent_ids.add(dest_id)
        try:
            if reply_msg:
                await reply_msg.copy(chat_id=dest_id)
            else:
                await client.send_message(dest_id, text)
            done += 1
            await asyncio.sleep(0.05)  # 20 msg/sec max (safe)
        except (UserIsBlocked, InputUserDeactivated, PeerIdInvalid):
            blocked += 1
            # ✅ FIX: Auto-cleanup — blocked/deactivated users DB se hata do
            try:
                await users_col.delete_one({"user_id": dest_id})
                await groups_col.delete_one({"chat_id": dest_id})
            except Exception:
                pass
        except FloodWait as e:
            await asyncio.sleep(min(e.value + 2, 60))
            try:
                if reply_msg:
                    await reply_msg.copy(chat_id=dest_id)
                else:
                    await client.send_message(dest_id, text)
                done += 1
            except (UserIsBlocked, InputUserDeactivated, PeerIdInvalid):
                blocked += 1
                try:
                    await users_col.delete_one({"user_id": dest_id})
                    await groups_col.delete_one({"chat_id": dest_id})
                except Exception:
                    pass
            except Exception:
                failed += 1
        except Exception as e:
            # ✅ FIX: RANDOM_ID_DUPLICATE = message already delivered by Telegram
            if "RANDOM_ID_DUPLICATE" in str(e):
                done += 1  # Count as success — message pehle hi chala gaya
            elif "PEER_ID_INVALID" in str(e) or "USER_DEACTIVATED" in str(e) or "USER_IS_BLOCKED" in str(e):
                blocked += 1
                try:
                    await users_col.delete_one({"user_id": dest_id})
                    await groups_col.delete_one({"chat_id": dest_id})
                except Exception:
                    pass
            else:
                failed += 1

     if target in ["users", "all"]:
         # DISTINCT user_ids only
         seen = set()
         async for doc in users_col.find({}, {"user_id": 1}):
             uid_bc = doc.get("user_id")
             if not uid_bc or uid_bc in seen: continue
             seen.add(uid_bc)
             total += 1
             await _send_one(uid_bc)
             if total % 100 == 0:
                 elapsed = int(time.time() - start_time)
                 try: await sm.edit(f"📡 **Broadcasting...**\n\n✅ {done} | ❌ {failed} | 🚫 {blocked}\nTotal: {total} | Time: {elapsed}s")
                 except: pass

     if target in ["groups", "all"]:
         seen_g = set()
         async for doc in groups_col.find({}, {"chat_id": 1}):
             cid_bc = doc.get("chat_id")
             if not cid_bc or cid_bc in seen_g: continue
             seen_g.add(cid_bc)
             total += 1
             await _send_one(cid_bc)
             if total % 50 == 0:
                 elapsed = int(time.time() - start_time)
                 try: await sm.edit(f"📡 **Broadcasting...**\n\n✅ {done} | ❌ {failed} | 🚫 {blocked}\nTotal: {total} | Time: {elapsed}s")
                 except: pass

     elapsed = int(time.time() - start_time)
     await sm.edit(
         f"📡 **Broadcast Complete!** ✅\n\n"
         f"📊 **Stats:**\n"
         f"├ Total unique: **{total}**\n"
         f"├ ✅ Success: **{done}**\n"
         f"├ ❌ Failed: **{failed}**\n"
         f"├ 🚫 Blocked: **{blocked}**\n"
         f"└ ⏱ Time: **{elapsed}s**"
     )

@bot.on_message(filters.command("setcommands") & filters.user(ADMINS))
async def set_commands(client, message: Message):
    from pyrogram.types import BotCommand
    cmds = [
        BotCommand("start", "Bot shuru karo"),
        BotCommand("help", "Help guide"),
        BotCommand("premium", "Premium plans"),
        BotCommand("mystats", "Apni stats"),
        BotCommand("referlink", "Refer link"),
        BotCommand("request", "File request"),
    ]
    await client.set_bot_commands(cmds)
    await message.reply("✅ Commands set!")


# ═══════════════════════════════════════
#  AD MANAGER — ADMIN COMMAND
# ═══════════════════════════════════════
@bot.on_message(filters.command("myid") & filters.private)
async def my_id_cmd(client, message: Message):
    """User ka ID batao (debugging ke liye)."""
    uid = message.from_user.id
    is_admin = uid in ADMINS
    await message.reply(
        f"🆔 **Your Telegram ID:** `{uid}`\n"
        f"👑 Admin: {'✅ Haan' if is_admin else '❌ Nahi'}\n"
        f"📋 ADMINS list: `{ADMINS}`\n"
        f"🌐 KOYEB_URL: `{'Set ✅' if KOYEB_URL else 'NOT SET ❌'}`\n"
        f"📢 AD_SYSTEM: `{'ON ✅' if AD_SYSTEM_ENABLED else 'OFF ❌'}`"
    )


@bot.on_message(filters.command("admanager") & filters.private)
async def ad_manager_cmd(client, message: Message):
    """Admin ke liye Ad Manager — miniapp open karo."""
    uid = message.from_user.id
    if uid not in ADMINS:
        await message.reply("❌ Sirf admin use kar sakta hai.")
        return
    if not KOYEB_URL:
        await message.reply(
            "❌ **KOYEB_URL set nahi hai!**\n\n"
            "`.env` mein `KOYEB_URL=https://your-app.koyeb.app` set karo."
        )
        return
    try:
        total, active_count = await ad_count()
        admin_url = f"{KOYEB_URL}/?uid={uid}&admin_id={uid}&page=admanager"
        await message.reply(
            f"📢 **Ad Manager**\n\n"
            f"📊 Total Ads: `{total}` | ✅ Active: `{active_count}`\n\n"
            f"**Ad System Status:** {'🟢 ON' if AD_SYSTEM_ENABLED else '🔴 OFF'}\n\n"
            f"⚠️ _Ad system on hai lekin active ad nahi hai toh user ko seedha file milegi!_\n\n"
            f"Neeche button se Ad Manager kholo:",
            reply_markup=InlineKeyboardMarkup([
                [InlineKeyboardButton("📢 Ad Manager (Mini App)", web_app=WebAppInfo(url=admin_url))],
                [InlineKeyboardButton("🌐 Browser Mein Kholo", url=admin_url)],
            ])
        )
    except Exception as e:
        logger.error(f"admanager cmd error: {e}")
        await message.reply(f"❌ Error: `{e}`\n\nBot logs check karo.")


@bot.on_message(filters.command("adstatus") & filters.user(ADMINS) & filters.private)
async def ad_status_cmd(client, message: Message):
    """Ad system ka status aur active ads dikhao."""
    try:
        total, active_count = await ad_count()
        from database import ad_active_list
        active_ads = await ad_active_list()

        text = (
            f"📢 **Ad System Status**\n\n"
            f"**Mode:** {'🟢 ON (Ad Verify)' if AD_SYSTEM_ENABLED else '🔴 OFF (Shortlink)'}\n"
            f"**KOYEB_URL:** {'✅ Set' if KOYEB_URL else '❌ NOT SET'}\n\n"
            f"📊 **Ads:**\n"
            f"├ Total: `{total}`\n"
            f"└ Active: `{active_count}`\n\n"
        )
        if active_ads:
            text += "**Active Ads:**\n"
            for i, ad in enumerate(active_ads, 1):
                exp = ad.get('expiry_date')
                text += (
                    f"`{i}.` **{ad.get('title','')}**\n"
                    f"    👁 Views: {ad.get('impressions',0)} | "
                    f"⏱ {ad.get('timer1',60)}s+{ad.get('timer2',30)}s"
                )
                if exp:
                    text += f" | 📅 Expires: {str(exp)[:10]}"
                text += "\n"
        else:
            text += "⚠️ **Koi active ad nahi!**\n`/admanager` se ad create karo — tab tak file free milegi!\n"

        await message.reply(text)
    except Exception as e:
        await message.reply(f"❌ Error: `{e}`")


# ═══════════════════════════════════════
#  GROUP EVENTS
# ═══════════════════════════════════════
@bot.on_message(filters.new_chat_members)
async def on_new_member(client, message: Message):
    me = (await client.get_me()).id
    for member in message.new_chat_members:
        if member.id == me:
            await save_group(message.chat)
            link_text = ""
            try:
                invite = await client.export_chat_invite_link(message.chat.id)
                if invite: link_text = f"\n🔗 {invite}"
            except: pass
            await send_log(f"➕ #BotAdded\n🏘 {message.chat.title}\n🆔 `{message.chat.id}`{link_text}")
            await message.reply(
                f"🌍 **AsBhai Drop Bot Aa Gaya!** 🎉\n\n"
                f"Movie/series ka naam type karo!\n"
                f"⚙️ Settings: `/gsettings`\n📢 {MAIN_CHANNEL}"
            )
        elif not member.is_bot:
            await save_user(member)

@bot.on_message(filters.left_chat_member)
async def on_left_member(client, message: Message):
    me = (await client.get_me()).id
    if message.left_chat_member and message.left_chat_member.id == me:
        await groups_col.delete_one({"chat_id": message.chat.id})
        await send_log(f"➖ #BotRemoved\n🏘 {message.chat.title}\n🆔 `{message.chat.id}`")

# ═══════════════════════════════════════
#  INLINE MODE
# ═══════════════════════════════════════
@bot.on_inline_query()
async def inline_search(client, query):
    q = query.query.strip()
    if len(q) < 2: return
    from pyrogram.types import InlineQueryResultArticle, InputTextMessageContent
    found = await do_search(q, limit=5)
    me = await client.get_me()
    items = []
    for idx, msg in enumerate(found):
        fname = get_file_name(msg)
        link = f"https://t.me/{me.username}?start=getfile_{query.from_user.id}_{msg.id}"
        items.append(InlineQueryResultArticle(
            title=fname[:60], description="Click karke PM mein file lo",
            input_message_content=InputTextMessageContent(f"🗂 **{fname}**\n\n[📥 File Lo]({link})")
        ))
    if not items:
        items = [InlineQueryResultArticle(title=f"'{q}' nahi mila", description="Kuch aur try karo",
            input_message_content=InputTextMessageContent(f"❌ '{q}' nahi mila."))]
    await query.answer(items, cache_time=10)

# ═══════════════════════════════════════
#  ADMIN PANEL
# ═══════════════════════════════════════
@bot.on_message(filters.command("admin") & filters.user(ADMINS) & filters.private)
async def admin_panel(client, message: Message):
    s = await get_settings()
    total_users = await users_col.count_documents({})
    total_groups = await groups_col.count_documents({})
    prem_users = await premium_col.count_documents({})
    pending_pay = await payments_col.count_documents({"status": "pending"})
    from database import ad_count as _adc
    _total_ads, _active_ads = await _adc()
    await message.reply(
        f"👑 **Admin Panel**\n"
        f"👤 Users: {total_users} | 🏘 Groups: {total_groups}\n"
        f"💎 Premium: {prem_users} | 💰 Pending: {pending_pay}\n\n"
        f"🔧 Maintenance: {'ON🔴' if s.get('maintenance') else 'OFF✅'}\n"
        f"📢 Force Sub: {'ON✅' if s.get('force_sub') else 'OFF❌'}\n"
        f"📊 Ad System: {'ON✅' if AD_SYSTEM_ENABLED else 'OFF❌'} ({_active_ads} active ads)\n"
        f"🛡 Link Protect: {'ON✅' if s.get('link_protection', True) else 'OFF❌'}\n\n"
        f"/stats | /settings | /fsub | /adstatus | /broadcast"
    )

# ═══════════════════════════════════════
#  START BOT
# ═══════════════════════════════════════
def start_bot():
    db_set_clients(bot, userbot)
    routes_set_clients(bot, userbot)

    if userbot:
        userbot.start()
        logger.info("✅ Userbot started")
        # CHANNEL_INVALID fix: userbot ko FILE_CHANNEL join karwao
        import threading as _threading
        def _join_file_channel():
            import time as _t; _t.sleep(5)
            async def _do_join():
                try:
                    await userbot.get_chat(FILE_CHANNEL)
                    logger.info("✅ Userbot already in FILE_CHANNEL")
                except Exception:
                    try:
                        await userbot.join_chat(FILE_CHANNEL)
                        logger.info("✅ Userbot joined FILE_CHANNEL!")
                    except Exception as _je:
                        logger.warning(f"⚠️ Userbot channel join: {_je}")
            if userbot.loop and userbot.loop.is_running():
                asyncio.run_coroutine_threadsafe(_do_join(), userbot.loop)
        _threading.Thread(target=_join_file_channel, daemon=True).start()
    else:
        logger.warning("⚠️ STRING_SESSION missing!")

    logger.info("🚀 AsBhai Drop Bot starting...")

    def _start_scheduler_thread():
        import time as _time
        _time.sleep(4)
        try:
            loop = bot.loop
            if not loop or not loop.is_running(): return
            async def _start():
                await run_aiohttp_server()

                # MongoDB TTL index for search cache
                await ensure_search_cache_ttl()

                # Userbot watchdog — reconnects every 15 min if disconnected
                async def _userbot_watchdog():
                    while True:
                        await asyncio.sleep(15 * 60)
                        if userbot:
                            try:
                                if not userbot.is_connected:
                                    logger.warning("⚠️ [Watchdog] Userbot down — reconnecting...")
                                    for _att in range(1, 4):
                                        try:
                                            await userbot.start()
                                            logger.info("✅ [Watchdog] Userbot reconnected!")
                                            break
                                        except Exception as _e:
                                            logger.error(f"[Watchdog] Attempt {_att}/3: {_e}")
                                            await asyncio.sleep(15 * _att)
                                else:
                                    logger.info("💚 [Watchdog] Userbot OK")
                            except Exception as _we:
                                logger.error(f"[Watchdog] Error: {_we}")
                asyncio.ensure_future(_userbot_watchdog())

                def _run_cleanup():
                    if bot.loop and bot.loop.is_running():
                        asyncio.run_coroutine_threadsafe(cleanup(), bot.loop)

                scheduler.add_job(_run_cleanup, 'interval', hours=1)

                # ✅ Premium expiry reminder — daily 10 AM IST
                def _run_expiry():
                    if bot.loop and bot.loop.is_running():
                        asyncio.run_coroutine_threadsafe(_send_premium_expiry_reminders(), bot.loop)

                scheduler.add_job(_run_expiry, 'cron', hour=10, minute=0, timezone=IST)
                scheduler.start()
                logger.info("✅ Scheduler + aiohttp + watchdog started")
            asyncio.run_coroutine_threadsafe(_start(), loop)
        except Exception as e:
            logger.error(f"Startup thread error: {e}")

    Thread(target=_start_scheduler_thread, daemon=True).start()

    # ── Chat Join Request Handler ──
    @bot.on_chat_join_request()
    async def auto_approve_join_request(client, request):
        """
        Join request handler — FIXED:
        • req_only channels: KABHI auto-approve NAHI — admin manually karega
        • Force sub channel (verification-only): KABHI auto-approve NAHI
        • Normal public channels (join_by_request=False): auto-approve karo
        
        Agar koi bhi channel force-sub ke liye use ho raha hai,
        usse req_only=True mark karo /fsub add -100xxx Title req se.
        """
        try:
            from database import jr_add_user, get_fsub_list
            uid   = request.from_user.id
            ch_id = request.chat.id

            # Step 1: MongoDB mein save karo (har request track hogi)
            await jr_add_user(uid, ch_id)
            logger.info(f"📝 Join request tracked: {uid} → {ch_id}")

            # Step 2: Fsub list check karo
            fsub_list = await get_fsub_list()
            channel_in_fsub = False
            is_req_only = False

            for ch in fsub_list:
                if ch.get("id") == ch_id:
                    channel_in_fsub = True
                    # req_only flag check
                    if ch.get("req_only", False):
                        is_req_only = True
                    break

            # ✅ MAIN FIX: Agar channel force-sub list mein hai
            # → KABHI auto-approve mat karo, chahe req_only ho ya na ho
            # → Force sub channel sirf verification ke liye hota hai
            # → Admin khud approve karega
            if channel_in_fsub:
                try:
                    chat_obj = await client.get_chat(ch_id)
                    chat_title = getattr(chat_obj, "title", "Channel")
                    mode_msg = (
                        "📨 **Request Mode Channel**" if is_req_only
                        else "🔐 **Verification Channel**"
                    )
                    await client.send_message(
                        uid,
                        f"✅ **{chat_title}** mein request submit ho gayi!\n\n"
                        f"{mode_msg}\n"
                        f"Admin review karenge aur approve karenge.\n\n"
                        f"⏳ Tab tak bot use karte raho — group mein search karo! 🔍\n"
                        f"💎 Premium lo — kisi bhi channel join ki zaroorat nahi!"
                    )
                except Exception as _me:
                    logger.warning(f"JR msg send fail uid={uid}: {_me}")
                # ← CRITICAL: return karo — auto-approve mat karo
                logger.info(f"🚫 Auto-approve skipped (fsub channel): {uid} → {ch_id}")
                return

            # Step 3: Channel fsub list mein NAHI hai
            # Normal channel — Telegram setting check karo
            try:
                chat_obj = await client.get_chat(ch_id)
                join_by_req = getattr(chat_obj, "join_by_request", False)
                chat_title  = getattr(chat_obj, "title", "Channel")
            except Exception:
                join_by_req = True   # Safe default — approve mat karo
                chat_title  = "Channel"

            if not join_by_req:
                # ✅ Auto-approve (public/private-open channel)
                try:
                    await client.approve_chat_join_request(ch_id, uid)
                    logger.info(f"✅ Auto-approved (non-fsub): {uid} → {ch_id}")
                    await client.send_message(
                        uid,
                        f"🎉 **{chat_title}** mein join ho gaye!\n\n"
                        f"Ab wapas group mein aao aur movie search karo! 🎬"
                    )
                except Exception as _ae:
                    logger.warning(f"Auto-approve failed {uid}→{ch_id}: {_ae}")
            else:
                # join_by_request=True — admin approve karega
                try:
                    await client.send_message(
                        uid,
                        f"📨 **{chat_title}** mein request bhej di!\n\n"
                        f"Admin approve karenge — thodi der mein join ho jaoge. ✅"
                    )
                except: pass

        except Exception as e:
            logger.warning(f"auto_approve_join_request error: {e}")

    bot.run()

if __name__ == "__main__":
    start_bot()