akn/manage/bots_manage.py

# -*- coding: utf-8 -*-
import time
import os
import uuid
import asyncio
import pyromod
from pyromod.helpers import ikb
from datetime import datetime as dt
from pyrogram import *
from pyrogram import Client as ren, filters
from pyrogram.types import *

from akn.utils.database import db as db_client
from akn.manage.settings_control import verify_bot_ownershipdl
from akn.utils.logger import LOGS
from config import PRIVATE_LOGS

@Client.on_callback_query(filters.regex("^my_userbotub$"))
async def userbotdashboardub(client: Client, callback: CallbackQuery):
    user_id = callback.from_user.id
    
    user_data = await db_client.session.find_one({"user_id": user_id})
    if not user_data or "user_client" not in user_data:
        return await callback.answer("❌ No userbot found!", show_alert=True)

    bot_data = user_data["user_client"][0]
    status = bot_data.get("status", "pending")

    status_icons = {
        "approved": "✅",
        "rejected": "❌", 
        "pending": "⏳",
        "stopped": "🛑",
        "error": "⚠️"
    }
    start = time.time()
    await client.get_me()
    end = time.time()
    latency = (end - start) * 1000

    text = f"""
🔧 **Your Userbot Dashboard**

🆔 **User ID:** `{user_id}`
📛 **Status:** {status_icons.get(status, "�")} {status.capitalize()}
⏰ **Last Active:** {bot_data.get("timestamp", "Never")}
✔ **Pong:** `{latency:.2f} ms`
🔗 **Session:** {'Set' if bot_data.get("session_string") else 'Not Set'}
"""

    buttons = []
    if not bot_data.get("session_string"):
        buttons.append(
            [InlineKeyboardButton("➕ Set Session String", callback_data="set_sessionub")]
        )
    else:
        buttons.append(
            [InlineKeyboardButton("🔄 Update Session", callback_data="update_sessionub")]
        )

    if status == "approved":
        buttons.extend([
            [InlineKeyboardButton("❔ Check Status", callback_data=f"statusub_{user_id}")]
        ])
    
    buttons.append(
        [InlineKeyboardButton("🔄 Refresh", callback_data="my_userbotub"),
         InlineKeyboardButton("⚙️ Settings", callback_data="ubsetting")]
    )
    buttons.append(
        [InlineKeyboardButton("🔙 Back", callback_data="confirm_userbot")]
    )
    await callback.message.edit_text(
        text,
        reply_markup=InlineKeyboardMarkup(buttons)
    )
    await callback.answer()

@Client.on_callback_query(filters.regex("^session_exportuball$"))
async def export_all_sessionsub(client, callback):
    user_data = await db_client.session.find_one({"user_id": callback.from_user.id})
    if not user_data or not user_data.get("user_client"):
        return await callback.answer("⚠️ No sessions to export!", show_alert=True)

    sessions = user_data["user_client"]
    export_text = ""
    for index, session in enumerate(sessions, 1):
        status = session.get("status", "unknown")
        is_active = session.get("is_active", False)
        session_str = session.get("session_string", "None")
        export_text += (
            f"Userbot #{index}\n"
            f"Status: {status}\n"
            f"Active: {is_active}\n"
            f"Session: {session_str}\n\n"
        )
    filename = f"sessions_{callback.from_user.id}.txt"
    with open(filename, "w") as f:
        f.write(export_text)

    try:
        await callback.message.edit_text("Downloading export all session.....", reply_markup=None)
        await asyncio.sleep(2)
        await callback.message.edit_text("Uploading.....", reply_markup=None)
        await callback.message.edit_media(
            media=InputMediaDocument(
                media=filename,
                caption="📝 Your session details.\n\n"
                        "<b>Never share your session string with anyone</b>"
            ),
            reply_markup=InlineKeyboardMarkup([
                [InlineKeyboardButton("❌ Close", callback_data="close")]
            ])
        )
        os.remove(filename) 
        await callback.answer()
    except Exception as e:
        LOGS.error(f"Error in export_all_sessionsub handler: {str(e)}")
        await callback.answer(f"❌ Error: Please try again later.", True)
        try:
            os.remove(filename)
        except:
            pass

@Client.on_callback_query(filters.regex("^ubsetting$"))
async def userbotsettingsub(client: Client, callback: CallbackQuery):
    user_id = callback.from_user.id
    
    buttons = [
        [InlineKeyboardButton("📝 Session Info", callback_data="session_infoub"),
         InlineKeyboardButton("🗑 Delete Userbot", callback_data="delete_userbotub")
        ],
        [InlineKeyboardButton("📥 Export All Sessions", callback_data="session_exportuball")],
        [InlineKeyboardButton("🔙 Back", callback_data="my_userbotub")]
    ]

    await callback.message.edit_text(
        "⚙️ **Userbot Settings**\n\n"
        "Manage your userbot configuration:",
        reply_markup=InlineKeyboardMarkup(buttons)
    )
    await callback.answer()

@Client.on_callback_query(filters.regex("^delete_userbotub$"))
async def sessionconfirmdeleteub(client, callback):
    await callback.message.edit_text(
        "⚠️ This will permanently delete your userbot!",
        reply_markup=InlineKeyboardMarkup([
            [InlineKeyboardButton("✅ Confirm", "confirm_rmdeleteub")],
            [InlineKeyboardButton("❌ Cancel", "my_userbotub")]
        ])
    )

@Client.on_callback_query(filters.regex("^confirm_rmdeleteub$"))
async def sessionrmdeleteubnow(client, callback):
    user_mention = callback.from_user.mention
    user_data = await db_client.session.find_one({"user_id": callback.from_user.id})
    if not user_data or not user_data.get("user_client"):
        return await callback.answer(
            "❌ You don't have any Userbot deployed yet!",
            show_alert=True
        )
    try:
        result = await db_client.session.update_one(
            {
                "_id": user_data["_id"],
                "user_id": callback.from_user.id,
                "user_client.user_id": callback.from_user.id
            },
            {"$pull": {"user_client": {"user_id": callback.from_user.id}}}
        )
        if result.modified_count == 1:
            await callback.message.edit_text(
                f"✅ User `{callback.from_user.id}` has been permanently removed",
                reply_markup=InlineKeyboardMarkup([
                    [InlineKeyboardButton("⭐ My Userbot", callback_data="my_userbotub")]
                ])
            )
            await notify_admins_user(
                client=client,
                message=f"🛑 <b>Deleted Userbot</b>\n\n"
                        f"👤 User: {user_mention} ({callback.from_user.id})\n",
                user_id=callback.from_user.id,
                is_button=False
            )
        else:
            raise Exception("Database update failed")
    except Exception as e:
        LOGS.error(f"Error in sessionrmdeleteubnow handler: {str(e)}")
        await callback.answer(f"❌ Error: Please try again later.", True)
        await notify_admins_user(
            client=client,
            message=f"🚨 <b>Error in sessionrmdeleteubnow handler</b>\n\n"
                    f"👤 User: {user_mention} ({callback.from_user.id})\n"
                    f"🧠 Error: <code>{str(e)}</code>",
            user_id=callback.from_user.id,
            is_button=False
        )

@Client.on_callback_query(filters.regex("^session_infoub$"))
async def infosessionstringub(client: Client, callback: CallbackQuery):
    user_data = await db_client.session.find_one({"user_id": callback.from_user.id})
    if not user_data or not user_data.get("user_client"):
        return await callback.answer(
            "❌ You don't have any Userbot deployed yet!",
            show_alert=True
        )
    user = user_data["user_client"][0]
    await callback.message.edit_text(
        "🔒 <b>Session String Secure</b>\n\n"
        f"Copy: `{user.get('session_string', 'Nothing')}`\n\n"
        "Important: <b>Never share your session string with anyone</b>",
        reply_markup=ikb([
            [("« Back", "ubsetting")]
        ])
    )
    await callback.answer()

@Client.on_callback_query(filters.regex("^(set_sessionub|update_sessionub)$"))
async def asksessionstringub(client: Client, callback: CallbackQuery):
    user_data = await db_client.session.find_one({"user_id": callback.from_user.id})
    if not user_data or not user_data.get("user_client"):
        return await callback.answer(
            "❌ You don't have any Userbot deployed yet!",
            show_alert=True
        )
    _user_string = user_data.get("user_client")[0]
    user_mention = callback.from_user.mention
    await callback.message.edit_text(
        "🔑 **Session String Setup: @sessiondevbot**\n\n"
        "Please send your session string in this format:\n\n"
        "`ABCDEF1234ghIklzyx57W2v1u123ew11*********`\n\n"
        "⚠️ This will replace your current session!\n\n"
        "Cancelled use /cancel",
        reply_markup=None
    )
    try:
        string_msg = await client.listen(callback.message.chat.id, timeout=60)
        if string_msg.text.lower() == "/cancel":
            await string_msg.reply(
                "❌ Cancelled.",
                reply_markup=ikb([
                    [("« Back", "my_userbotub")]
                ])
            )
            return

        string_update = string_msg.text.strip()
        if string_update == _user_string.get("session_string"):
            return await string_msg.reply(
                "❌ Error Session string same use different!",
                reply_markup=ikb([
                    [("« Back", "my_userbotub")]

                ])
            )
        await db_client.session.update_one(
            {
                "user_id": callback.from_user.id,
                "user_client.user_id": callback.from_user.id
            },
            {
                "$set": {
                    "user_client.$.session_string": string_update
                }
            }
        )
        await string_msg.reply(
            "✅ Session string updated successfully!",
            reply_markup=ikb([
                [("« Back", "my_userbotub")]
            ])
        )
        await notify_admins_user(
            client=client,
            message=f"💬 <b>Update Session</b>\n\n"
                    f"👤 User: {user_mention} ({callback.from_user.id})",
            user_id=user_id,
            is_button=True
        )
        return
    except TimeoutError:
        await callback.message.reply_text("⌛ Session setup timed out")
    except Exception as e:
        await callback.message.reply_text(f"❌ Error: Please try again later.")
        await notify_admins_user(
            client=client,
            message=f"🚨 <b>Error in asksessionstringub handler</b>\n\n"
                    f"👤 User: {user_mention} ({callback.from_user.id})\n"
                    f"🧠 Error: <code>{str(e)}</code>",
            user_id=callback.from_user.id,
            is_button=False
        )

@ren.on_callback_query(filters.regex("^my_bots$"))
async def show_user_bots(client: Client, callback: CallbackQuery):
    user_id = callback.from_user.id
    user_mention = callback.from_user.mention

    try:
        user_data = await db_client.alldl_bot.find_one({"user_id": user_id})
        if not user_data or not user_data.get("bots"):
            return await callback.answer(
                "❌ You don't have any bots deployed yet!",
                show_alert=True
            )

        bots_by_status = {
            "approved": [],
            "pending": [],
            "rejected": [],
            "error": []
        }
        for bot in user_data["bots"]:
            status = bot.get("status", "pending")
            bots_by_status.setdefault(status, []).append(bot)

        start = time.time()
        await client.get_me()
        end = time.time()
        latency = (end - start) * 1000
        message_text = f"🤖 <b>Your Bot Dashboard</b> 👋 {user_mention}\n\n"
        message_text += f"🏷 <b>Tier:</b> {'💎 Premium' if user_data.get('is_premium') else '🆓 Free'}\n"
        message_text += f"🚀 <b>Active Bots:</b> {sum(1 for b in bots_by_status['approved'] if b.get('is_active'))}\n"
        message_text += f"⏳ <b>Pending:</b> {len(bots_by_status['pending'])}\n"
        message_text += f"❌ <b>Rejected:</b> {len(bots_by_status['rejected'])}\n"
        message_text += f"✔ <b>Pong:</b> `{latency:.2f} ms`\n\n"

        buttons = []

        if bots_by_status["approved"]:
            message_text += "✅ <b>Approved Bots:</b>\n"
            for bot in bots_by_status["approved"]:
                bot_name = bot.get("bot_username", "Unknown")
                status = "🟢 Online" if bot.get("is_active") else "🔴 Offline"
                message_text += f"┣ {bot_name} - {status} - `{latency:.2f}`\n"

                buttons.append([
                    InlineKeyboardButton(
                        f"⚙️ Manage {bot_name}",
                        callback_data=f"botmgmt_{bot.get('uuid', 'unknown')}"
                    )
                ])

        if bots_by_status["pending"]:
            message_text += "\n🕒 <b>Pending Approval:</b>\n"
            for bot in bots_by_status["pending"]:
                token_preview = bot.get("bot_token", "")[:10] + "..."
                submitted_time = bot.get("timestamp", "Unknown")
                message_text += f"┣ {token_preview} - {submitted_time}\n"

                buttons.append([
                    InlineKeyboardButton(
                        f"❌ Cancel {token_preview}",
                        callback_data=f"cancelbotdl_{bot.get('uuid', 'unknown')}"
                    )
                ])

        if bots_by_status["rejected"]:
            message_text += "\n❌ <b>Rejected Bots:</b>\n"
            for bot in bots_by_status["rejected"]:
                token_preview = bot.get("bot_token", "")[:10] + "..."
                reason = bot.get("admin_action", {}).get("reason", "No reason given")
                message_text += f"┣ {token_preview} - {reason}\n"

                buttons.append([
                    InlineKeyboardButton(
                        f"🔁 Resubmit {token_preview}",
                        callback_data=f"resubmitdl_{bot.get('uuid', 'unknown')}"
                    )
                ])

        buttons.append([
            InlineKeyboardButton("🆕 Deploy New Bot", callback_data="tutorial_alldlbot"),
            InlineKeyboardButton("💎 Upgrade Plan", callback_data="premium_upgrades")
        ])
        buttons.append([
            InlineKeyboardButton("🔄 Refresh", callback_data="my_bots"),
            InlineKeyboardButton("❌ Close", callback_data="close")
        ])
        buttons.append([
            InlineKeyboardButton("« Back", callback_data="customzie_bot"),
        ])

        try:
            await callback.message.edit_text(
                message_text,
                reply_markup=InlineKeyboardMarkup(buttons)
            )
        except Exception as e:
            LOGS.error(f"Edit message failed: {e}")
            await callback.answer("⚠️ Failed to update message, try again.", show_alert=True)

        await callback.answer()

    except Exception as e:
        LOGS.error(f"Error in my_bots handler: {str(e)}")
        await callback.answer("⚠️ Error fetching your bots!", show_alert=True)
        await client.send_message(
            PRIVATE_LOGS,
            f"🚨 <b>Error in my_bots handler</b>\n\n"
            f"👤 User: {user_mention} ({user_id})\n"
            f"🧠 Error: <code>{str(e)}</code>"
        )

@ren.on_callback_query(filters.regex(r"^botmgmt_(\w+)$"))
async def manage_single_bot(client: Client, callback: CallbackQuery):
    bot_uuid = callback.matches[0].group(1)
    user_id = callback.from_user.id
    user_mention = callback.from_user.mention

    try:
        user_data = await db_client.alldl_bot.find_one(
            {
                "user_id": user_id,
                "bots.uuid": bot_uuid
            },
            {"bots.$": 1}
        )

        if not user_data or not user_data.get("bots"):
            return await callback.answer("❌ Bot not found!", show_alert=True)

        bot = user_data["bots"][0]
        bot_username = bot.get("bot_username", "Unknown")
        bot_uuid = bot.get("uuid", "???")

        status = "🟢 Online" if bot.get("is_active") else "🔴 Offline"
        last_active = bot.get("last_active", "Never")

        buttons = [
            [
                InlineKeyboardButton("🔄 Restart Bot", callback_data=f"restartdl_{bot_uuid}"),
                InlineKeyboardButton("🛑 Stop Bot", callback_data=f"stopbotdl_{bot_uuid}")
            ],
            [
                InlineKeyboardButton("📊 Stats", callback_data=f"botstatsdl_{bot_uuid}"),
                InlineKeyboardButton("⚙️ Settings", callback_data=f"botsettingsdl_{bot_uuid}")
            ],
            [InlineKeyboardButton("« Back", callback_data="my_bots")]
        ]

        await callback.message.edit_text(
            f"⚙️ <b>Managing {bot_username}</b>\n\n"
            f"Status: {status}\n"
            f"Last Active: {last_active}\n"
            f"UUID: <code>{bot_uuid}</code>\n\n"
            "Choose an action below:",
            reply_markup=InlineKeyboardMarkup(buttons)
        )
        await callback.answer()

    except Exception as e:
        LOGS.error(f"Bot management error: {str(e)}")
        await callback.answer("❌ Error managing bot!", show_alert=True)
        await client.send_message(
            PRIVATE_LOGS,
            f"🚨 <b>Error in single manage handler</b>\n\n"
            f"👤 User: {user_mention} ({user_id})\n"
            f"🧠 Error: <code>{str(e)}</code>"
        )

@ren.on_callback_query(filters.regex(r"^botsettingsdl_(\w+)$"))
async def handle_bot_settingsdl(client: Client, callback: CallbackQuery):
    try:
        bots_uuid = callback.matches[0].group(1)
        user_id = callback.from_user.id
        user_mention = callback.from_user.mention

        if not await verify_bot_ownershipdl(user_id, bots_uuid):
            await callback.answer("❌ Unauthorized access!", show_alert=True)
            return

        bot_data = await db_client.alldl_bot.find_one(
            {"user_id": user_id, "bots.uuid": bots_uuid},
            {"bots.$": 1}
        )

        if not bot_data:
            return await callback.answer("❌ Bot not found!", show_alert=True)

        buttons = InlineKeyboardMarkup([
            [InlineKeyboardButton("🔐 Reset Token", callback_data=f"start_reset_tokendl")],
            [InlineKeyboardButton("🗑 Delete Bot", callback_data=f"deletebotdl_{bots_uuid}")],
            [InlineKeyboardButton("« Back to bot", callback_data="my_bots")]
        ])

        await callback.message.edit_text(
            f"⚙️ Bot Settings\n\n"
            f"🆔 UUID: `{bots_uuid}`\n"
            f"🔗 Username: {bot_data['bots'][0].get('bot_username', 'N/A')}\n"
            f"📅 Created: {bot_data['bots'][0].get('created_at', 'Unknown')}",
            reply_markup=buttons
        )
        await callback.answer()

    except Exception as e:
        LOGS.error(f"Settings error: {str(e)}")
        await callback.answer("⚠️ Error loading settings!", show_alert=True)
        await client.send_message(
            PRIVATE_LOGS,
            f"🚨 <b>Error in settingdl handler</b>\n\n"
            f"👤 User: {user_mention} ({user_id})\n"
            f"🧠 Error: <code>{str(e)}</code>"
        )

@ren.on_callback_query(filters.regex("start_reset_tokendl"))
async def reset_tokendl_callbackx(client, callback_query):
    user_id = callback_query.from_user.id
    bot_data = await db_client.alldl_bot.find_one({"user_id": user_id})
    if not bot_data:
        await callback_query.answer("❌ Bot not found!", show_alert=True)
        return
    old_uuid = bot_data["bots"][0].get("uuid")
    await callback_query.message.edit_text(
        "✏️ Please send the UUID of the bot you want to reset.\n\nYou can cancel by typing `/cancel`\n\nYou can't this button is disabled.",
        reply_markup=ikb([
            [("🔒 Locked Cancel", "noop")]
        ])
    )
    try:
        uuid_msg = await client.listen(callback_query.message.chat.id, timeout=60)
        if uuid_msg.text.lower() == "/cancel":
            await uuid_msg.reply(
                "❌ Cancelled.",
                reply_markup=ikb([
                    [("« Back", "customzie_bot")]
                ])
            )
            return

        bots_uuid = uuid_msg.text.strip()
        if bots_uuid != old_uuid:
            await uuid_msg.reply(
                "❌ Token reset cancelled.",
                reply_markup=ikb([
                    [("« Back", "customzie_bot")]
                ])
            )
            return
        keyboard = InlineKeyboardMarkup([
            [
                InlineKeyboardButton("✅ Yes", callback_data=f"resettokendl_{bots_uuid}"),
                InlineKeyboardButton("❌ Cancel", callback_data=f"cancel_resetdl_{bots_uuid}")
            ]
        ])
        await uuid_msg.reply(
            f"Are you sure you want to reset the token for:\n`{bots_uuid}`",
            reply_markup=keyboard
        )
    except asyncio.TimeoutError:
        await callback_query.message.reply("⏰ Timeout. Please try again.")

@ren.on_callback_query(filters.regex(r"^(resettokendl|cancel_resetdl)_(\w+)$"))
async def tokenx_reset_flowdl(client: Client, callback: CallbackQuery):
    action, bot_uuid = callback.matches[0].groups()
    user_id = callback.from_user.id
    user_mention = callback.from_user.mention

    bot_data = await db_client.alldl_bot.find_one(
        {
            "user_id": user_id,
            "bots.uuid": bot_uuid
        },
        {"bots.$": 1}
    )

    if not bot_data:
        await callback.answer("❌ Bot not found!", show_alert=True)
        return

    if action == "cancel_resetdl":
        await callback.answer("Token reset cancelled ❌", show_alert=False)
        await callback.message.edit_text(
            "❌ Token reset cancelled.",
            reply_markup=ikb([
                [("« Back", "customzie_bot")]
            ])
        )
        return

    try:
        current_token = bot_data["bots"][0]["uuid"]
        new_token = str(uuid.uuid4())[:8]
        await db_client.alldl_bot.update_one(
            {
                "user_id": user_id,
                "bots.uuid": bot_uuid
            },
            {
                "$set": {
                    "bots.$.uuid": new_token,
                    "bots.$.updated_at": dt.now().strftime("%Y-%m-%d %H:%M:%S"),
                },
                "$push": {
                    "bots.$.old_tokens": {
                        "token": current_token,
                        "reset_at": dt.now().strftime("%Y-%m-%d %H:%M:%S")
                    }
                }
            }
        )
        await callback.message.edit_text(
            f"✅ Token has been reset successfully!\n\n`{new_token}`",
            reply_markup=None
        )
        await callback.answer("New token generated ✅", show_alert=False)

    except Exception as e:
        LOGS.error(f"Token reset error: {str(e)}")
        await callback.answer("❌ Failed to reset token. Please try again later.", True)
        await client.send_message(
            PRIVATE_LOGS,
            f"🚨 <b>Error in tokenx reset handler</b>\n\n"
            f"👤 User: {user_mention} ({user_id})\n"
            f"🧠 Error: <code>{str(e)}</code>"
        )

@ren.on_callback_query(filters.regex("^noop$"))
async def noopx_callback(client, callback_query):
    await callback_query.answer("🔒 This button is disabled.", show_alert=False)

@ren.on_callback_query(filters.regex(r"^deletebotdl_(\w+)$"))
async def handle_delete_botdl(client: Client, callback: CallbackQuery):
    try:
        bots_uuid = callback.matches[0].group(1)
        user_id = callback.from_user.id
        user_mention = callback.from_user.mention
        if not await verify_bot_ownershipdl(user_id, bots_uuid):
            await callback.answer("❌ Unauthorized access!", show_alert=True)
            return

        bot_data = await db_client.alldl_bot.find_one(
            {
                "user_id": user_id,
                "bots.uuid": bots_uuid,
            },
            {"bots.$": 1}
        )

        if not bot_data:
            await callback.answer("❌ Bot not found!", show_alert=True)
            return

        await callback.message.edit_text(
            f"⚠️ **Permanent Deletion**\n\n"
            f"🆔 UUID: `{bots_uuid}`\n"
            f"🔗 Username: {bot_data['bots'][0].get('bot_username', 'N/A')}\n\n"
            "This will immediately:\n"
            "1. Stop the bot instance\n"
            "2. Remove all download history\n"
            "3. Delete configuration data",
            reply_markup=InlineKeyboardMarkup([
                [InlineKeyboardButton("☠️ Confirm Delete", callback_data=f"confirmdeletedl_{bots_uuid}")],
                [InlineKeyboardButton("🔒 Cancel", callback_data=f"nodeletedl_{bots_uuid}")],
                [InlineKeyboardButton("« Back", callback_data="my_bots")]
            ])
        )
        await callback.answer()

    except Exception as e:
        LOGS.error(f"Delete init error: {str(e)}")
        await callback.answer("⚠️ Error processing request", show_alert=True)
        await client.send_message(
            PRIVATE_LOGS,
            f"🚨 <b>Error in delete_botdl handler</b>\n\n"
            f"👤 User: {user_mention} ({user_id})\n"
            f"🧠 Error: <code>{str(e)}</code>"
        )

@ren.on_callback_query(filters.regex(r"^(confirmdeletedl|nodeletedl)_(\w+)$"))
async def delete_confirmationdl(client: Client, callback: CallbackQuery):
    action, bots_uuid = callback.matches[0].groups()
    
    if action == "nodeletedl":
        await callback.message.edit_text(
            "✅ Deletion cancelled",
            reply_markup=InlineKeyboardMarkup([
                [InlineKeyboardButton("« Back", callback_data="my_bots")]
            ])
        )
        await callback.answer()
        return

    try:
        user_id = callback.from_user.id
        user_mention = callback.from_user.mention


        result = await db_client.alldl_bot.update_one(
            {"user_id": user_id},
            {"$pull": {"bots": {"uuid": bots_uuid}}}
        )

        if result.modified_count == 1:
            await callback.message.edit_text(
                "🗑️ **Bot Deleted**\n\n"
                f"All data for `{bots_uuid}` has been removed\n"
                f"Average review time: 24-48 hours",
                reply_markup=InlineKeyboardMarkup([
                    [InlineKeyboardButton("« Back", callback_data="customzie_bot")],
                ])
            )
            await notify_admins(
                client=client,
                message=f"🗑️ <b>Bot Deleted</b>\n\n"
                        f"User: {user_mention}\n"
                        f"UUID: {bots_uuid}\n",
                user_id=user_id,
                bots_uuid=bots_uuid
            )
        else:
            raise Exception("Database update failed")

    except Exception as e:
        LOGS.error(f"Deletion error: {str(e)}")
        await callback.message.edit_text("❌ Deletion failed. Please contact support.")
        await client.send_message(
            PRIVATE_LOGS,
            f"🚨 <b>Error indelete_confirmationdl handler</b>\n\n"
            f"👤 User: {user_mention} ({user_id})\n"
            f"🧠 Error: <code>{str(e)}</code>"
        )

@ren.on_callback_query(filters.regex(r"^resubmitdl_(\w+)$"))
async def xresubmission(client: Client, callback: CallbackQuery):
    try:
        bots_uuid = callback.matches[0].group(1)
        user_id = callback.from_user.id
        user_mention = callback.from_user.mention
        if not await verify_bot_ownershipdl(user_id, bots_uuid):
            await callback.answer("❌ Unauthorized access!", show_alert=True)
            return

        bot_data = await db_client.alldl_bot.find_one(
            {
                "user_id": user_id,
                "bots.uuid": bots_uuid,
                "bots.status": "rejected"
            },
            {"bots.$": 1}
        )

        if not bot_data:
            await callback.answer("❌ Bot not found or not eligible for resubmission", show_alert=True)
            return

        bot = bot_data["bots"][0]
        rejection_reason = bot.get("admin_action", {}).get("reason", "No reason provided")


        await callback.message.edit_text(
            f"🔄 **Resubmit Bot Request**\n\n"
            f"🆔 UUID: `{bots_uuid}`\n"
            f"❌ Previous Rejection Reason: {rejection_reason}\n\n"
            "Please confirm you want to resubmit this bot for approval:",
            reply_markup=InlineKeyboardMarkup([
                [InlineKeyboardButton("✅ Confirm Resubmit", callback_data=f"confirm_resubmitdl_{bots_uuid}")],
                [InlineKeyboardButton("❌ Cancel", callback_data=f"cancel_resubmitdl_")],
                [InlineKeyboardButton("« Back", callback_data="my_bots")]
            ])
        )
        await callback.answer()

    except Exception as e:
        LOGS.error(f"Resubmission init error: {str(e)}")
        await callback.answer("⚠️ Error processing request", show_alert=True)
        await client.send_message(
            PRIVATE_LOGS,
            f"🚨 <b>Error in xresubmission handler</b>\n\n"
            f"👤 User: {user_mention} ({user_id})\n"
            f"🧠 Error: <code>{str(e)}</code>"
        )

@ren.on_callback_query(filters.regex(r"^cancelbotdl_(\w+)$"))
async def handle_cancel_bot(client: Client, callback: CallbackQuery):
    try:
        bots_uuid = callback.matches[0].group(1)
        user_id = callback.from_user.id
        user_mention = callback.from_user.mention
        if not await verify_bot_ownershipdl(user_id, bots_uuid):
            await callback.answer("❌ Unauthorized access!", show_alert=True)
            return

        bot_data = await db_client.alldl_bot.find_one(
            {
                "user_id": user_id,
                "bots.uuid": bots_uuid,
                "bots.status": "pending"
            },
            {"bots.$": 1}
        )

        if not bot_data:
            await callback.answer("❌ No pending bot found with this ID", show_alert=True)
            return
    
        await callback.message.edit_text(
            f"⚠️ **Confirm Cancellation**\n\n"
            f"UUID: `{bots_uuid}`\n"
            f"Submitted: {bot_data['bots'][0].get('timestamp', 'Unknown')}\n\n"
            "This will permanently remove the bot request:",
            reply_markup=InlineKeyboardMarkup([
                [InlineKeyboardButton("🗑 Confirm Delete", callback_data=f"confirmcanceldl_{bots_uuid}")],
                [InlineKeyboardButton("🔙 Keep Request", callback_data=f"keepbotdl_{user_id}")],
                [InlineKeyboardButton("« Back", callback_data="my_bots")]
            ])
        )
        await callback.answer()

    except Exception as e:
        LOGS.error(f"Cancel init error: {str(e)}")
        await callback.answer("⚠️ Error processing request", show_alert=True)
        await client.send_message(
            PRIVATE_LOGS,
            f"🚨 <b>Error in cancel_bot handler</b>\n\n"
            f"👤 User: {user_mention} ({user_id})\n"
            f"🧠 Error: <code>{str(e)}</code>"
        )

@ren.on_callback_query(filters.regex(r"^confirmcanceldl_(\w+)$"))
async def confirm_cancel_bot(client: Client, callback: CallbackQuery):
    try:
        bots_uuid = callback.matches[0].group(1)
        user_id = callback.from_user.id
        user_mention = callback.from_user.mention
        if not await verify_bot_ownershipdl(user_id, bots_uuid):
            await callback.answer("❌ Unauthorized access!", show_alert=True)
            return

        result = await db_client.alldl_bot.update_one(
            {"user_id": user_id},
            {"$pull": {"bots": {"uuid": bots_uuid}}}
        )

        if result.modified_count == 1:
            await callback.message.edit_text(
                "✅ **Request Cancelled**\n\n"
                f"Bot `{bots_uuid}` has been permanently removed",
                reply_markup=InlineKeyboardMarkup([
                    [InlineKeyboardButton("📋 My Bots", callback_data="my_bots")]
                ])
            )
        else:
            raise Exception("Database update failed")

    except Exception as e:
        LOGS.error(f"Cancel error: {str(e)}")
        await callback.message.edit_text("❌ Failed to cancel request. Please contact support.")
        await client.send_message(
            PRIVATE_LOGS,
            f"🚨 <b>Error in confirm cancel handler</b>\n\n"
            f"👤 User: {user_mention} ({user_id})\n"
            f"🧠 Error: <code>{str(e)}</code>"
        )

@ren.on_callback_query(filters.regex(r"^confirm_resubmitdl_(\w+)$"))
async def confirm_resubmission(client: Client, callback: CallbackQuery):
    try:
        bots_uuid = callback.matches[0].group(1)
        user_id = callback.from_user.id
        user_mention = callback.from_user.mention
        if not await verify_bot_ownershipdl(user_id, bots_uuid):
            await callback.answer("❌ Unauthorized access!", show_alert=True)
            return

        result = await db_client.alldl_bot.update_one(
            {
                "user_id": user_id,
                "bots.uuid": bots_uuid
            },
            {
                "$set": {
                    "bots.$.status": "pending",
                    "bots.$.resubmitted_at": dt.now().strftime("%Y-%m-%d %H:%M:%S"),
                    "bots.$.admin_action.reviewed": False
                }
            }
        )

        if result.modified_count == 1:
            await callback.message.edit_text(
                f"✅ **Resubmission Successful**\n\n"
                f"Bot `{bots_uuid}` has been queued for admin review.\n"
                f"Average review time: 24-48 hours",
                reply_markup=InlineKeyboardMarkup([
                    [InlineKeyboardButton("📊 View Status", callback_data=f"statusdl_{user_id}")]
                ])
            )
            await notify_admins(
                client=client,
                message=f"Bot resubmitted: {bots_uuid} by {callback.from_user.mention}",
                user_id=user_id,
                bots_uuid=bots_uuid
            )
        else:
            raise Exception("Database update failed")

    except Exception as e:
        LOGS.error(f"Resubmission error: {str(e)}")
        await callback.message.edit_text("❌ Failed to resubmit. Please try again later.")
        await client.send_message(
            PRIVATE_LOGS,
            f"🚨 <b>Error in confirm_resubmission handler</b>\n\n"
            f"👤 User: {user_mention} ({user_id})\n"
            f"🧠 Error: <code>{str(e)}</code>"
        )

async def notify_admins_user(client, message, user_id, is_button=False):
     admin_buttons = InlineKeyboardMarkup([
        [InlineKeyboardButton("✅ Approve", callback_data=f"approved_ub_{user_id}"),
         InlineKeyboardButton("❌ Reject",  callback_data=f"rejected_ub_{user_id}")],
        [InlineKeyboardButton("👤 View User", url=f"tg://user?id={user_id}")]
    ])
     return await client.send_message(
         PRIVATE_LOGS,
         text=message,
         reply_markup=admin_buttons if is_button else None
    )

async def notify_admins(client, message, user_id, bots_uuid):
     admin_buttons = InlineKeyboardMarkup([
        [InlineKeyboardButton("✅ Approve", callback_data=f"approved_alldl_{user_id}_{bots_uuid}"),
         InlineKeyboardButton("❌ Reject",  callback_data=f"rejected_alldl_{user_id}_{bots_uuid}")],
        [InlineKeyboardButton("👤 View User", url=f"tg://user?id={user_id}")]
    ])
     return await client.send_message(
         PRIVATE_LOGS,
         text=message,
         reply_markup=admin_buttons
    )

@ren.on_callback_query(filters.regex(r"^cancel_resubmitdl_"))
async def cancel_resubmit(client: Client, callback: CallbackQuery):
    await callback.message.edit_text(
        "🚫 Resubmission cancelled",
        reply_markup=InlineKeyboardMarkup([
            [InlineKeyboardButton("« Back", callback_data="my_bots")]
        ])
    )
    await callback.answer()