akn/manage/bots_manage.py

# -*- coding: utf-8 -*-
import time
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

@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"cancelbot_{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(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()