import json

from aiogram import Router, F
from aiogram.types import CallbackQuery, Message, InlineKeyboardButton
from aiogram.utils.keyboard import InlineKeyboardBuilder
from aiogram.filters import Command
from aiogram.exceptions import TelegramBadRequest
from aiogram.fsm.context import FSMContext
from aiogram.fsm.state import State, StatesGroup
from sqlalchemy import func, select

from database.database import AsyncSessionLocal
from database.crud import (
    get_database_admin_users,
    get_setting,
    get_user_by_telegram_id,
    remove_user_admin,
    set_setting,
    set_user_admin,
    ensure_runtime_admin,
    update_user_verification,
)
from database.models import User, Order, GiftCard, Transaction, BannedPlayer
from core.config import config
from core.emojis import (
    BASE_EMOJI_ID_MAPPING,
    CUSTOM_EMOJI_SETTING_KEY,
    get_custom_emoji_overrides,
    get_effective_emoji_id,
    p_em,
    set_custom_emoji_override,
    set_custom_emoji_overrides,
)
from services.midasbuy_service import (
    create_checkout_payload,
    midasbuy_status_label,
    query_midasbuy_order,
    record_midasbuy_event,
)

router = Router()

class AdminState(StatesGroup):
    waiting_for_broadcast = State()
    waiting_for_giftcard = State()
    waiting_for_user_id = State()
    waiting_for_user_message = State()
    waiting_for_new_balance = State()
    waiting_for_start_verified = State()
    waiting_for_start_unverified = State()
    waiting_for_group_kyc = State()
    waiting_for_group_orders = State()
    waiting_for_group_receipts = State()
    waiting_for_zibal_merchant = State()
    waiting_for_card_number = State()
    waiting_for_card_name = State()
    waiting_for_nowpayments_api_key = State()
    waiting_for_usdt_rate = State()
    waiting_for_midasbuy_setting = State()
    waiting_for_new_admin_id = State()
    waiting_for_support_id = State()
    waiting_for_mandatory_channels = State()
    waiting_for_custom_emoji_id = State()
    waiting_for_custom_emoji_bulk = State()
    waiting_for_ban_player_id = State()
    waiting_for_unban_player_id = State()

EMOJI_PAGE_SIZE = 20
IMPORTANT_EMOJIS = [
    "🇮🇷", "🇦🇫", "🪙", "🎮", "✅", "❌", "📝", "👤", "📱", "🌐",
    "⏳", "🚨", "💳", "💎", "🔑", "📧", "🔥", "💰", "📦", "🛒",
]
ADMIN_EMOJI_ITEMS = IMPORTANT_EMOJIS + [
    emoji for emoji in BASE_EMOJI_ID_MAPPING.keys()
    if emoji not in IMPORTANT_EMOJIS
]
def _valid_custom_emoji_id(value: str) -> bool:
    return bool(value and value.strip().isdigit() and len(value.strip()) >= 10)

@router.message(Command("admin"))
async def admin_dashboard(message: Message, prefix_text: str = ""):
    async with AsyncSessionLocal() as session:
        if not await ensure_runtime_admin(session, message.from_user.id):
            return
        
    from database.models import Product
    async with AsyncSessionLocal() as session:
        users_count = await session.scalar(select(func.count(User.id)))
        orders_count = await session.scalar(select(func.count(Order.id)))
        sales_sum = await session.scalar(select(func.sum(Order.amount)).where(Order.status == 'completed')) or 0
        
        # Best sellers
        stmt = select(Order.product_id, func.count(Order.id).label('sales_count')).where(Order.status == 'completed').group_by(Order.product_id).order_by(func.count(Order.id).desc()).limit(3)
        best_sellers_rows = (await session.execute(stmt)).all()
        best_sellers_text = ""
        for i, row in enumerate(best_sellers_rows, 1):
            p = await session.get(Product, row.product_id)
            if p:
                best_sellers_text += f"   {i}. {p.name} ({row.sales_count} فروش)\n"
        if not best_sellers_text:
            best_sellers_text = "   - هنوز فروشی ثبت نشده است.\n"
            
    builder = InlineKeyboardBuilder()
    builder.button(text="📢 پیام همگانی", callback_data="admin_broadcast", style="primary")
    builder.button(text="👤 مدیریت کاربران", callback_data="admin_manage_user", style="primary")
    builder.button(text="🎁 افزودن گیفت کارت", callback_data="admin_add_giftcard", style="primary")
    builder.button(text="📋 مدیریت گیفت کارت‌ها", callback_data="admin_manage_gcs_1", style="primary")
    builder.button(text="🛒 مدیریت فروشگاه", callback_data="admin_manage_products", style="primary")
    builder.button(text="📦 مدیریت سفارش‌ها", callback_data="admin_manage_orders_1", style="primary")
    builder.button(text="📊 گزارش‌های دوره‌ای", callback_data="admin_periodic_reports", style="primary")
    builder.button(text="🚫 مسدودسازی آیدی بازی", callback_data="admin_banned_players", style="primary")
    builder.button(text="⚙️ تنظیمات متن /start", callback_data="admin_edit_start_text", style="success")
    builder.button(text="🛠 تنظیمات ربات", callback_data="admin_bot_settings", style="danger")
    builder.button(text="🔙 بازگشت به منوی کاربری", callback_data="back_to_main", style="danger")
    builder.adjust(2, 2, 2, 2, 2, 1)
    
    await message.answer(
        prefix_text +
        f"👑 <b>داشبورد مدیریت ربات</b>\n"
        f"〰️〰️〰️〰️〰️〰️〰️\n"
        f"👥 <b>تعداد کل کاربران:</b> {users_count}\n"
        f"📦 <b>تعداد کل سفارشات:</b> {orders_count}\n"
        f"💵 <b>مجموع درآمد (تکمیل شده):</b> {sales_sum:,.0f} تومان\n\n"
        f"🔥 <b>محصولات پرفروش:</b>\n{best_sellers_text}\n"
        f"👇 از منوی زیر جهت مدیریت بخش‌های مختلف استفاده کنید:",
        reply_markup=builder.as_markup()
    )

@router.callback_query(F.data == "admin_dashboard_back")
async def admin_dashboard_back(callback: CallbackQuery, state: FSMContext = None):
    if state:
        await state.clear()
    async with AsyncSessionLocal() as session:
        if not await ensure_runtime_admin(session, callback.from_user.id):
            return
            
    from database.models import Product
    async with AsyncSessionLocal() as session:
        users_count = await session.scalar(select(func.count(User.id)))
        orders_count = await session.scalar(select(func.count(Order.id)))
        sales_sum = await session.scalar(select(func.sum(Order.amount)).where(Order.status == 'completed')) or 0
        
        # Best sellers
        stmt = select(Order.product_id, func.count(Order.id).label('sales_count')).where(Order.status == 'completed').group_by(Order.product_id).order_by(func.count(Order.id).desc()).limit(3)
        best_sellers_rows = (await session.execute(stmt)).all()
        best_sellers_text = ""
        for i, row in enumerate(best_sellers_rows, 1):
            p = await session.get(Product, row.product_id)
            if p:
                best_sellers_text += f"   {i}. {p.name} ({row.sales_count} فروش)\n"
        if not best_sellers_text:
            best_sellers_text = "   - هنوز فروشی ثبت نشده است.\n"
            
    builder = InlineKeyboardBuilder()
    builder.button(text="📢 پیام همگانی", callback_data="admin_broadcast", style="primary")
    builder.button(text="👤 مدیریت کاربران", callback_data="admin_manage_user", style="primary")
    builder.button(text="🎁 افزودن گیفت کارت", callback_data="admin_add_giftcard", style="primary")
    builder.button(text="📋 مدیریت گیفت کارت‌ها", callback_data="admin_manage_gcs_1", style="primary")
    builder.button(text="🛒 مدیریت فروشگاه", callback_data="admin_manage_products", style="primary")
    builder.button(text="📦 مدیریت سفارش‌ها", callback_data="admin_manage_orders_1", style="primary")
    builder.button(text="📊 گزارش‌های دوره‌ای", callback_data="admin_periodic_reports", style="primary")
    builder.button(text="🚫 مسدودسازی آیدی بازی", callback_data="admin_banned_players", style="primary")
    builder.button(text="⚙️ تنظیمات متن /start", callback_data="admin_edit_start_text", style="success")
    builder.button(text="🛠 تنظیمات ربات", callback_data="admin_bot_settings", style="danger")
    builder.button(text="🔙 بازگشت به منوی کاربری", callback_data="back_to_main", style="danger")
    builder.adjust(2, 2, 2, 2, 2, 1)
    
    await callback.message.edit_text(
        f"👑 <b>داشبورد مدیریت ربات</b>\n"
        f"〰️〰️〰️〰️〰️〰️〰️\n"
        f"👥 <b>تعداد کل کاربران:</b> {users_count}\n"
        f"📦 <b>تعداد کل سفارشات:</b> {orders_count}\n"
        f"💵 <b>مجموع درآمد (تکمیل شده):</b> {sales_sum:,.0f} تومان\n\n"
        f"🔥 <b>محصولات پرفروش:</b>\n{best_sellers_text}\n"
        f"👇 از منوی زیر جهت مدیریت بخش‌های مختلف استفاده کنید:",
        reply_markup=builder.as_markup()
    )
    await callback.answer()

@router.callback_query(F.data == "admin_broadcast")
async def ask_broadcast_msg(callback: CallbackQuery, state: FSMContext):
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ لغو", callback_data="admin_dashboard_back")
    await callback.message.edit_text(
        "📢 <b>ارسال پیام همگانی</b>\n\n"
        "لطفاً متن پیام، عکس یا بنر خود را ارسال کنید:",
        reply_markup=builder.as_markup()
    )
    await state.set_state(AdminState.waiting_for_broadcast)
    await callback.answer()

@router.message(AdminState.waiting_for_broadcast)
async def process_broadcast(message: Message, state: FSMContext):
    if message.text == "/cancel":
        await state.clear()
        return await admin_dashboard(message, prefix_text="❌ عملیات ارسال همگانی لغو شد.\n\n")
        
    async with AsyncSessionLocal() as session:
        users = await session.execute(select(User.telegram_id))
        all_users = users.scalars().all()
        
    import asyncio
    from aiogram.exceptions import TelegramRetryAfter
    
    await message.answer(f"📢 ارسال پیام همگانی به {len(all_users)} کاربر آغاز شد...")
    
    success_count = 0
    failed_count = 0
    
    for uid in all_users:
        # تاخیر کوچک برای جلوگیری از بلاک شدن توسط تلگرام
        await asyncio.sleep(0.05)
        
        for attempt in range(3):
            try:
                await message.copy_to(chat_id=uid)
                success_count += 1
                break
            except TelegramRetryAfter as e:
                await asyncio.sleep(e.retry_after)
            except Exception:
                failed_count += 1
                break
                
    report_text = (
        f"✅ <b>ارسال همگانی تکمیل شد.</b>\n\n"
        f"🟢 موفق: {success_count} کاربر\n"
        f"🔴 ناموفق (مسدود شده و غیره): {failed_count} کاربر\n\n"
    )
    await state.clear()
    await admin_dashboard(message, prefix_text=report_text)

@router.callback_query(F.data == "admin_periodic_reports")
async def ask_periodic_reports(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return
    builder = InlineKeyboardBuilder()
    builder.button(text="🕒 ۲۴ ساعت گذشته", callback_data="rep_period_24h")
    builder.button(text="📅 ۷ روز گذشته", callback_data="rep_period_7d")
    builder.button(text="📆 ۳۰ روز گذشته", callback_data="rep_period_30d")
    builder.button(text="🔙 بازگشت به داشبورد", callback_data="admin_dashboard_back")
    builder.adjust(1, 2, 1)
    
    await callback.message.edit_text(
        "📊 <b>انتخاب بازه زمانی گزارش‌گیری:</b>\n\n"
        "لطفاً بازه مورد نظر برای دریافت گزارش را انتخاب کنید:",
        reply_markup=builder.as_markup()
    )
    await callback.answer()

@router.callback_query(F.data.startswith("rep_period_"))
async def show_periodic_report_results(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return
        
    period = callback.data.split("_")[2]
    from datetime import datetime, timedelta
    
    if period == "24h":
        delta = timedelta(hours=24)
        title = "۲۴ ساعت گذشته"
    elif period == "7d":
        delta = timedelta(days=7)
        title = "۷ روز گذشته"
    else:
        delta = timedelta(days=30)
        title = "۳۰ روز گذشته"
        
    from database.models import Product
    since = datetime.utcnow() - delta
    
    async with AsyncSessionLocal() as session:
        new_users_count = await session.scalar(
            select(func.count(User.id)).where(User.created_at >= since)
        ) or 0
        
        orders_count = await session.scalar(
            select(func.count(Order.id)).where(Order.created_at >= since)
        ) or 0
        
        sales_sum = await session.scalar(
            select(func.sum(Order.amount)).where(
                Order.status == 'completed', 
                Order.created_at >= since
            )
        ) or 0
        
        # Best sellers
        stmt = select(Order.product_id, func.count(Order.id).label('sales_count'))\
            .where(Order.status == 'completed', Order.created_at >= since)\
            .group_by(Order.product_id)\
            .order_by(func.count(Order.id).desc())\
            .limit(5)
        best_sellers_rows = (await session.execute(stmt)).all()
        best_sellers_text = ""
        for i, row in enumerate(best_sellers_rows, 1):
            p = await session.get(Product, row.product_id)
            if p:
                best_sellers_text += f"   {i}. {p.name} ({row.sales_count} فروش)\n"
        if not best_sellers_text:
            best_sellers_text = "   - در این بازه زمانی فروشی ثبت نشده است.\n"
            
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت به منوی گزارشات", callback_data="admin_periodic_reports")
    
    report_text = (
        f"📊 <b>گزارش فروشگاه ({title})</b>\n"
        f"〰️〰️〰️〰️〰️〰️〰️\n"
        f"👥 <b>کاربران جدید:</b> {new_users_count} نفر\n"
        f"📦 <b>تعداد سفارشات جدید:</b> {orders_count}\n"
        f"💵 <b>مجموع فروش/درآمد:</b> {sales_sum:,.0f} تومان\n\n"
        f"🔥 <b>محصولات پرفروش:</b>\n{best_sellers_text}"
    )
    
    await callback.message.edit_text(report_text, reply_markup=builder.as_markup())
    await callback.answer()

@router.callback_query(F.data == "admin_excel_template")
async def send_excel_template(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return
        
    import pandas as pd
    import os
    
    data = {
        "Category": ["پابجی موبایل", "گیفت کارت", "پابجی موبایل"],
        "Name": ["60 UC Pubg", "GiftCard Steam 5$", "325 UC Pubg"],
        "Price": [65000, 320000, 325000],
        "Description": ["واریز با آیدی در کمتر از ۵ دقیقه", "تحویل آنی گیفت کارت استیم", "واریز با آیدی در کمتر از ۵ دقیقه"],
        "Stock": [-1, 20, -1]
    }
    df = pd.DataFrame(data)
    
    os.makedirs("utils", exist_ok=True)
    template_path = "utils/products_template.xlsx"
    
    try:
        df.to_excel(template_path, index=False)
        
        from aiogram.types import FSInputFile
        document = FSInputFile(template_path)
        
        await callback.bot.send_document(
            chat_id=callback.message.chat.id,
            document=document,
            filename="products_template.xlsx",
            caption="📥 <b>قالب استاندارد اکسل محصولات</b>\n\n"
                    "طبق ساختار این فایل اکسل محصولات خود را پر کرده و سپس فایل تکمیل شده را برای ربات ارسال کنید تا محصولات اضافه و بروزرسانی شوند."
        )
        
        if os.path.exists(template_path):
            os.remove(template_path)
            
    except Exception as e:
        await callback.message.answer(f"❌ خطا در ساخت و ارسال فایل اکسل: {e}")
        
    await callback.answer()

@router.callback_query(F.data.startswith("admin_add_giftcard"))
async def ask_giftcard_info(callback: CallbackQuery, state: FSMContext):
    parts = callback.data.split("_")
    page = int(parts[3]) if len(parts) > 3 else 1
    per_page = 10
    
    from database.models import Product
    from sqlalchemy import select
    async with AsyncSessionLocal() as session:
        stmt = select(Product).order_by(Product.id.desc())
        products = (await session.execute(stmt)).scalars().all()
        
    if not products:
        return await callback.answer("هیچ محصولی در دیتابیس یافت نشد.", show_alert=True)
        
    total_pages = (len(products) + per_page - 1) // per_page
    if total_pages == 0:
        total_pages = 1
    start = (page - 1) * per_page
    end = start + per_page
    current_prods = products[start:end]
    
    builder = InlineKeyboardBuilder()
    for p in current_prods:
        builder.button(text=f"📦 {p.name}", callback_data=f"sel_gc_prod_{p.id}")
        
    nav_buttons = []
    if page > 1:
        nav_buttons.append(InlineKeyboardButton(text="⬅️ قبلی", callback_data=f"admin_add_giftcard_{page-1}"))
    if page < total_pages:
        nav_buttons.append(InlineKeyboardButton(text="بعدی ➡️", callback_data=f"admin_add_giftcard_{page+1}"))
        
    builder.adjust(1)
    if nav_buttons:
        builder.row(*nav_buttons)
    builder.row(InlineKeyboardButton(text="❌ لغو", callback_data="admin_dashboard_back"))
        
    await callback.message.edit_text(
        f"🎁 <b>افزودن گیفت کارت جدید</b> (صفحه {page}/{total_pages})\n\n"
        f"لطفاً محصولی که می‌خواهید برای آن کد اضافه کنید را از لیست زیر انتخاب کنید:",
        reply_markup=builder.as_markup()
    )

@router.callback_query(F.data.startswith("sel_gc_prod_"))
async def select_giftcard_product(callback: CallbackQuery, state: FSMContext):
    prod_id = int(callback.data.split("_")[3])
    from database.models import Product
    async with AsyncSessionLocal() as session:
        prod = await session.get(Product, prod_id)
        if not prod:
            return await callback.answer("محصول یافت نشد!", show_alert=True)
            
    await state.update_data(target_gc_prod_id=prod_id, target_gc_prod_name=prod.name)
    await state.set_state(AdminState.waiting_for_giftcard)
    
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت به محصولات", callback_data="admin_add_giftcard_1")
    builder.button(text="❌ انصراف", callback_data="admin_dashboard_back")
    builder.adjust(1)
    
    await callback.message.edit_text(
        f"🎁 <b>افزودن گیفت کارت برای محصول:</b> {prod.name}\n\n"
        "شما می‌توانید کدها را به دو روش اضافه کنید:\n\n"
        "۱. <b>ارسال متن مستقیم:</b>\n"
        "کدها را خط به خط (زیر هم) وارد کنید.\n"
        "<code>Code1\nCode2\nCode3...</code>\n\n"
        "۲. <b>ارسال فایل متنی (.txt):</b>\n"
        "فایل حاوی کدها را اینجا ارسال کنید.",
        reply_markup=builder.as_markup()
    )
    await callback.answer()

@router.message(AdminState.waiting_for_giftcard)
async def process_giftcard_add(message: Message, state: FSMContext):
    if message.text and message.text == "/cancel":
        await state.clear()
        return await admin_dashboard(message, prefix_text="❌ عملیات افزودن گیفت کارت لغو شد.\n\n")
        
    data = await state.get_data()
    prod_id = data.get("target_gc_prod_id")
    prod_name = data.get("target_gc_prod_name", "نامعلوم")
    
    if not prod_id:
        return await message.answer("❌ خطای سیستمی! محصولی انتخاب نشده است. لطفاً مجدداً شروع کنید.")
        
    codes = []
    
    if message.document:
        doc = message.document
        import os
        ext = os.path.splitext(doc.file_name)[1].lower()
        if ext != '.txt':
            builder = InlineKeyboardBuilder()
            builder.button(text="🔙 بازگشت", callback_data="admin_add_giftcard_1")
            return await message.answer(
                p_em("⚠️ لطفاً فقط فایل متنی <code>.txt</code> ارسال کنید."),
                reply_markup=builder.as_markup()
            )
            
        file_path = f"utils/temp_gc_{message.from_user.id}.txt"
        os.makedirs("utils", exist_ok=True)
        await message.bot.download(doc, destination=file_path)
        
        try:
            with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
                raw_lines = [line.strip() for line in f.readlines()]
                
            for line in raw_lines:
                cleaned = line.strip()
                if cleaned:
                    if "," in cleaned:
                        codes.extend([c.strip() for c in cleaned.split(",") if c.strip()])
                    else:
                        codes.append(cleaned)
        except Exception as e:
            if os.path.exists(file_path):
                os.remove(file_path)
            return await admin_dashboard(message, prefix_text=f"❌ خطا در خواندن فایل: {e}\n\n")
            
        if os.path.exists(file_path):
            os.remove(file_path)
            
    else:
        import re
        codes_str = message.text
        codes = [c.strip() for c in re.split(r'[,\n]+', codes_str) if c.strip()]
        
    if not codes:
        return await message.answer("❌ هیچ کدی یافت نشد! لطفاً کدها را صحیح وارد کنید.")
        
    async with AsyncSessionLocal() as session:
        from database.models import GiftCard
        from sqlalchemy import select
        added = 0
        for code in codes:
            exists = await session.scalar(select(GiftCard).where(GiftCard.code == code))
            if not exists:
                gc = GiftCard(product_id=prod_id, code=code)
                session.add(gc)
                added += 1
        await session.commit()
        
    await state.clear()
    await admin_dashboard(message, prefix_text=f"✅ تعداد {added} کد با موفقیت به محصول <b>{prod_name}</b> اضافه شد.\n\n")

@router.callback_query(F.data.startswith("admin_manage_gcs_"))
async def manage_giftcards_list(callback: CallbackQuery):
    page = int(callback.data.split("_")[3])
    per_page = 10
    
    from database.models import Product
    async with AsyncSessionLocal() as session:
        # Get all products that have gift cards (sold or unsold)
        stmt = select(Product).join(GiftCard).group_by(Product.id).order_by(Product.id.desc())
        products = (await session.execute(stmt)).scalars().all()
        
    if not products:
        return await callback.answer("هیچ محصولی دارای گیفت‌کارت یافت نشد.", show_alert=True)
        
    total_pages = (len(products) + per_page - 1) // per_page
    start = (page - 1) * per_page
    end = start + per_page
    current_prods = products[start:end]
    
    builder = InlineKeyboardBuilder()
    for p in current_prods:
        builder.button(text=f"📋 {p.name}", callback_data=f"gcs_prod_{p.id}_1")
        
    nav_buttons = []
    if page > 1:
        nav_buttons.append(InlineKeyboardButton(text="⬅️ قبلی", callback_data=f"admin_manage_gcs_{page-1}"))
    if page < total_pages:
        nav_buttons.append(InlineKeyboardButton(text="بعدی ➡️", callback_data=f"admin_manage_gcs_{page+1}"))
        
    builder.adjust(1)
    if nav_buttons:
        builder.row(*nav_buttons)
        
    await callback.message.edit_text(
        f"📋 <b>مدیریت گیفت‌کارت‌ها</b> (صفحه {page}/{total_pages})\n\n"
        f"لطفاً محصول مورد نظر را برای مشاهده کدهای موجود انتخاب کنید:",
        reply_markup=builder.as_markup()
    )

@router.callback_query(F.data.startswith("gcs_prod_"))
async def manage_product_gcs(callback: CallbackQuery):
    parts = callback.data.split("_")
    prod_id = int(parts[2])
    page = int(parts[3])
    per_page = 5
    
    from database.models import Product
    async with AsyncSessionLocal() as session:
        prod = await session.get(Product, prod_id)
        stmt = select(GiftCard).where(GiftCard.product_id == prod_id, GiftCard.is_sold == False).order_by(GiftCard.id.desc())
        gcs = (await session.execute(stmt)).scalars().all()
        
    total_count = len(gcs)
    if total_count == 0:
        builder = InlineKeyboardBuilder()
        builder.button(text="🔙 بازگشت", callback_data="admin_manage_gcs_1")
        return await callback.message.edit_text(
            f"📦 <b>{prod.name}</b>\n\nهیچ کد موجود و فروخته‌نشده‌ای برای این محصول وجود ندارد.",
            reply_markup=builder.as_markup()
        )
        
    total_pages = (total_count + per_page - 1) // per_page
    start = (page - 1) * per_page
    end = start + per_page
    current_gcs = gcs[start:end]
    
    builder = InlineKeyboardBuilder()
    text = f"📦 <b>{prod.name}</b>\nتعداد کل کدهای موجود: {total_count}\n\nبرای حذف هر کد روی دکمه مربوطه بزنید:\n\n"
    
    for gc in current_gcs:
        builder.button(text=f"🗑 حذف: {gc.code}", callback_data=f"del_gc_{gc.id}_{prod_id}_{page}")
        
    nav_buttons = []
    if page > 1:
        nav_buttons.append(InlineKeyboardButton(text="⬅️", callback_data=f"gcs_prod_{prod_id}_{page-1}"))
    if page < total_pages:
        nav_buttons.append(InlineKeyboardButton(text="➡️", callback_data=f"gcs_prod_{prod_id}_{page+1}"))
        
    builder.adjust(1)
    if nav_buttons:
        builder.row(*nav_buttons)
        
    builder.row(InlineKeyboardButton(text="🔙 لیست محصولات", callback_data="admin_manage_gcs_1"))
    
    await callback.message.edit_text(text, reply_markup=builder.as_markup())

@router.callback_query(F.data.startswith("del_gc_"))
async def delete_giftcard_code(callback: CallbackQuery):
    parts = callback.data.split("_")
    gc_id = int(parts[2])
    prod_id = int(parts[3])
    page = int(parts[4])
    
    async with AsyncSessionLocal() as session:
        gc = await session.get(GiftCard, gc_id)
        if gc and not gc.is_sold:
            await session.delete(gc)
            await session.commit()
            await callback.answer("✅ کد گیفت‌کارت حذف شد.", show_alert=True)
        else:
            await callback.answer("❌ این کد یافت نشد یا قبلاً فروخته شده است.", show_alert=True)
            
    # Refresh the page by calling the previous handler manually
    callback.data = f"gcs_prod_{prod_id}_{page}"
    await manage_product_gcs(callback)

async def send_manage_users_menu(message: Message, state: FSMContext = None, prefix_text: str = ""):
    if state:
        await state.clear()
        
    async with AsyncSessionLocal() as session:
        stmt = select(User).order_by(User.id.desc()).limit(10)
        users = (await session.execute(stmt)).scalars().all()
        
    builder = InlineKeyboardBuilder()
    for u in users:
        builder.button(
            text=f"👤 {u.full_name or 'بدون نام'} ({u.telegram_id})", 
            callback_data=f"adm_usr_det_{u.telegram_id}"
        )
        
    builder.button(text="🔍 جستجو با آیدی عددی", callback_data="admin_search_user_prompt")
    builder.button(text="🔙 بازگشت به داشبورد", callback_data="admin_dashboard_back")
    builder.adjust(1)
    
    text = prefix_text + (
        "👤 <b>مدیریت کاربران ربات</b>\n\n"
        "لیست آخرین کاربران ثبت‌نام شده در زیر آمده است. برای مشاهده جزئیات روی نام کاربر کلیک کنید یا دکمه جستجو را بزنید:"
    )
    await message.answer(text, reply_markup=builder.as_markup())

async def send_user_details(message: Message, user_id: int, prefix_text: str = ""):
    async with AsyncSessionLocal() as session:
        user = await get_user_by_telegram_id(session, user_id)
        
    if not user:
        return await message.answer("❌ کاربر یافت نشد!")
        
    builder = InlineKeyboardBuilder()
    builder.button(text="💰 تغییر موجودی", callback_data=f"edit_balance_{user.telegram_id}")
    builder.button(text="✉️ ارسال پیام", callback_data=f"admin_send_msg_{user.telegram_id}")
    if not user.is_verified:
        builder.button(text="✅ تایید احراز هویت", callback_data=f"approve_kyc_{user.telegram_id}")
    else:
        builder.button(text="🗑 حذف/ریست احراز هویت", callback_data=f"reset_kyc_{user.telegram_id}")
    
    is_blocked = getattr(user, "is_blocked", False)
    block_text = "🔓 رفع مسدودیت" if is_blocked else "🔒 مسدود کردن"
    builder.button(text=block_text, callback_data=f"adm_toggle_block_{user.telegram_id}")
    
    builder.button(text="🔙 بازگشت به مدیریت کاربران", callback_data="admin_manage_user")
    builder.adjust(1)
    
    is_blocked_str = "🔴 مسدود شده" if is_blocked else "🟢 فعال"
    text = prefix_text + (
        f"👤 <b>اطلاعات کاربر</b>\n\n"
        f"آیدی: <code>{user.telegram_id}</code>\n"
        f"نام: {user.full_name}\n"
        f"نام کاربری: @{user.username or 'ندارد'}\n"
        f"موجودی: {user.wallet_balance:,.0f} تومان\n"
        f"احراز هویت: {'✅ تایید شده' if user.is_verified else '❌ تایید نشده'}\n"
        f"وضعیت حساب: {is_blocked_str}\n"
        f"تاریخ ثبت‌نام: {user.created_at.strftime('%Y-%m-%d')}"
    )
    await message.answer(text, reply_markup=builder.as_markup())

@router.callback_query(F.data == "admin_manage_user")
async def ask_user_id_for_manage(callback: CallbackQuery, state: FSMContext):
    await state.clear()
    
    async with AsyncSessionLocal() as session:
        stmt = select(User).order_by(User.id.desc()).limit(10)
        users = (await session.execute(stmt)).scalars().all()
        
    builder = InlineKeyboardBuilder()
    for u in users:
        builder.button(
            text=f"👤 {u.full_name or 'بدون نام'} ({u.telegram_id})", 
            callback_data=f"adm_usr_det_{u.telegram_id}"
        )
        
    builder.button(text="🔍 جستجو با آیدی عددی", callback_data="admin_search_user_prompt")
    builder.button(text="🔙 بازگشت به داشبورد", callback_data="admin_dashboard_back")
    builder.adjust(1)
    
    await callback.message.edit_text(
        "👤 <b>مدیریت کاربران ربات</b>\n\n"
        "لیست آخرین کاربران ثبت‌نام شده در زیر آمده است. برای مشاهده جزئیات روی نام کاربر کلیک کنید یا دکمه جستجو را بزنید:",
        reply_markup=builder.as_markup()
    )
    await callback.answer()


@router.message(AdminState.waiting_for_user_id)
async def process_user_search(message: Message, state: FSMContext):
    user_id_str = message.text.strip()
    if not user_id_str.isdigit():
        return await send_manage_users_menu(message, state, prefix_text="⚠️ لطفاً فقط مقدار عددی آیدی را وارد کنید.\n\n")
        
    user_id = int(user_id_str)
    async with AsyncSessionLocal() as session:
        user = await get_user_by_telegram_id(session, user_id)
        
    if not user:
        return await send_manage_users_menu(message, state, prefix_text="❌ کاربری با این آیدی در دیتابیس یافت نشد.\n\n")
        
    await state.clear()
    await send_user_details(message, user_id)

@router.callback_query(F.data.startswith("edit_balance_"))
async def ask_new_balance(callback: CallbackQuery, state: FSMContext):
    user_id = int(callback.data.split("_")[2])
    await state.update_data(edit_user_id=user_id)
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ لغو", callback_data=f"adm_usr_det_{user_id}")
    await callback.message.edit_text(
        f"💰 <b>تغییر موجودی کاربر</b>\n\n"
        f"لطفاً موجودی جدید (به تومان) را برای کاربر <code>{user_id}</code> وارد کنید:",
        reply_markup=builder.as_markup()
    )
    await state.set_state(AdminState.waiting_for_new_balance)
    await callback.answer()

@router.message(AdminState.waiting_for_new_balance)
async def process_new_balance(message: Message, state: FSMContext):
    data = await state.get_data()
    user_id = data.get("edit_user_id")
    
    if not message.text.isdigit() and not (message.text.startswith("-") and message.text[1:].isdigit()):
        return await send_user_details(message, user_id, prefix_text="⚠️ مبلغ وارد شده نامعتبر است. لطفاً مجدداً وارد کنید.\n\n")
        
    new_balance = float(message.text)
    
    async with AsyncSessionLocal() as session:
        user = await get_user_by_telegram_id(session, user_id)
        if user:
            user.wallet_balance = new_balance
            await session.commit()
            
    await state.clear()
    await send_user_details(message, user_id, prefix_text=f"✅ موجودی کاربر {user_id} به {new_balance:,.0f} تومان تغییر یافت.\n\n")


@router.callback_query(F.data.startswith("approve_kyc_"))
async def approve_kyc(callback: CallbackQuery):
    async with AsyncSessionLocal() as session:
        from database.crud import get_group_id
        group_kyc = await get_group_id(session, "kyc", config.admin_group_id)
        if callback.from_user.id not in config.admin_ids and callback.message.chat.id != group_kyc:
            await callback.answer("شما دسترسی ندارید!", show_alert=True)
            return
        
    user_id = int(callback.data.split("_")[2])
    
    async with AsyncSessionLocal() as session:
        await update_user_verification(session, user_id, is_verified=True)
        
    # ویرایش پیام گروه
    await callback.message.edit_reply_markup(reply_markup=None)
    await callback.message.reply(f"✅ احراز هویت کاربر {user_id} توسط ادمین تایید شد.")
    
    # اطلاع به کاربر
    try:
        await callback.bot.send_message(
            chat_id=user_id, 
            text=p_em("🎉 <b>تبریک!</b> احراز هویت شما تایید شد.\nحالا می‌توانید از منوی /start وارد فروشگاه شوید.")
        )
    except Exception:
        pass
    await callback.answer("تایید شد")

@router.callback_query(F.data.startswith("reject_kyc_"))
async def reject_kyc(callback: CallbackQuery):
    async with AsyncSessionLocal() as session:
        from database.crud import get_group_id
        group_kyc = await get_group_id(session, "kyc", config.admin_group_id)
        if callback.from_user.id not in config.admin_ids and callback.message.chat.id != group_kyc:
            await callback.answer("شما دسترسی ندارید!", show_alert=True)
            return

    user_id = int(callback.data.split("_")[2])
    
    # ویرایش پیام گروه
    await callback.message.edit_reply_markup(reply_markup=None)
    await callback.message.reply(f"❌ احراز هویت کاربر {user_id} توسط ادمین رد شد.")
    
    # اطلاع به کاربر
    try:
        await callback.bot.send_message(
            chat_id=user_id, 
            text=p_em("❌ متاسفانه احراز هویت شما تایید نشد. لطفاً اطلاعات معتبر ارسال کنید یا با پشتیبانی تماس بگیرید.")
        )
    except Exception:
        pass
    await callback.answer("رد شد")

@router.callback_query(F.data.startswith("approve_receipt_"))
async def approve_receipt(callback: CallbackQuery):
    async with AsyncSessionLocal() as session:
        from database.crud import get_group_id
        group_receipts = await get_group_id(session, "receipts", config.admin_group_id)
        if callback.from_user.id not in config.admin_ids and callback.message.chat.id != group_receipts:
            return await callback.answer("عدم دسترسی", show_alert=True)
        
    _, _, user_id_str, amount_str = callback.data.split("_")
    user_id = int(user_id_str)
    amount = float(amount_str)
    
    from services.wallet_service import charge_wallet
    async with AsyncSessionLocal() as session:
        success = await charge_wallet(session, user_id, amount, charge_type='rial_charge')
        
    if success:
        await callback.message.edit_reply_markup(reply_markup=None)
        await callback.message.reply(f"✅ مبلغ {amount:,.0f} تومان به کیف پول کاربر {user_id} واریز شد.")
        try:
            await callback.bot.send_message(
                chat_id=user_id,
                text=p_em(f"✅ <b>شارژ موفق</b>\nمبلغ {amount:,.0f} تومان به کیف پول شما اضافه شد.")
            )
        except Exception:
            pass
    await callback.answer()

@router.callback_query(F.data.startswith("reject_receipt_"))
async def reject_receipt(callback: CallbackQuery):
    async with AsyncSessionLocal() as session:
        from database.crud import get_group_id
        group_receipts = await get_group_id(session, "receipts", config.admin_group_id)
        if callback.from_user.id not in config.admin_ids and callback.message.chat.id != group_receipts:
            return await callback.answer("عدم دسترسی", show_alert=True)
            
    user_id = int(callback.data.split("_")[2])
    
    await callback.message.edit_reply_markup(reply_markup=None)
    await callback.message.reply(f"❌ رسید واریزی کاربر {user_id} توسط ادمین رد شد.")
    try:
        await callback.bot.send_message(
            chat_id=user_id,
            text=p_em("❌ متاسفانه فیش واریزی شما تایید نشد. لطفاً در صورت وجود مشکل با پشتیبانی تماس بگیرید.")
        )
    except Exception:
        pass
    await callback.answer("رد شد")

@router.callback_query(F.data.startswith("order_done_"))
async def mark_order_done(callback: CallbackQuery):
    # مربوط به گروه واریزکنندگان
    _, _, order_id, user_id = callback.data.split("_")
    
    async with AsyncSessionLocal() as session:
        order = await session.get(Order, int(order_id))
        if order and order.status != "completed":
            order.status = "completed"
            record_midasbuy_event(order, "finished", {"source": "group_manual_delivery", "status": "finished"})
            await session.commit()
            
    await callback.message.edit_reply_markup(reply_markup=None)
    await callback.message.reply(f"✅ سفارش {order_id} توسط {callback.from_user.full_name} انجام شد.")
    
    try:
        await callback.bot.send_message(
            chat_id=int(user_id),
            text=p_em(f"✅ <b>سفارش انجام شد</b>\nسفارش شما (شماره {order_id}) با موفقیت تکمیل و واریز شد!")
        )
    except Exception:
        pass
    await callback.answer()

@router.message(F.document)
async def handle_excel_upload(message: Message, state: FSMContext = None):
    if message.from_user.id not in config.admin_ids: 
        return
        
    doc = message.document
    import os
    ext = os.path.splitext(doc.file_name)[1].lower()
    
    if ext not in ['.xlsx', '.xls', '.csv', '.xlsm']:
        return await message.answer("لطفاً فقط فایل اکسل (.xlsx, .xls, .xlsm) یا CSV (.csv) ارسال کنید.")
        
    file_path = f"utils/products_temp{ext}"
    await message.bot.download(doc, destination=file_path)
    
    from services.excel_service import import_products_from_excel
    async with AsyncSessionLocal() as session:
        result = await import_products_from_excel(session, file_path)
        
    if os.path.exists(file_path):
        os.remove(file_path)
        
    from handlers.admin_shop import send_manage_products_menu
    if result["status"] == "success":
        fmt_text = "اکسل" if "excel" in result.get("format", "") else "CSV"
        await send_manage_products_menu(
            message,
            state,
            prefix_text=f"✅ فایل {fmt_text} با موفقیت پردازش شد.\nتعداد {result['count']} محصول در دیتابیس اضافه/بروزرسانی شد.\n\n"
        )
    else:
        await send_manage_products_menu(
            message,
            state,
            prefix_text=f"❌ خطا در پردازش فایل:\n{result['message']}\n\n"
        )


@router.callback_query(F.data == "admin_search_user_prompt")
async def admin_search_user_prompt(callback: CallbackQuery, state: FSMContext):
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ انصراف", callback_data="admin_manage_user")
    await callback.message.edit_text(
        "👤 <b>جستجوی کاربر</b>\n\n"
        "لطفاً آیدی عددی (Telegram ID) کاربر مورد نظر را بفرستید:",
        reply_markup=builder.as_markup()
    )
    await state.set_state(AdminState.waiting_for_user_id)
    await callback.answer()

@router.callback_query(F.data.startswith("adm_usr_det_"))
async def show_user_detail_by_callback(callback: CallbackQuery):
    user_id = int(callback.data.split("_")[3])
    async with AsyncSessionLocal() as session:
        user = await get_user_by_telegram_id(session, user_id)
        
    if not user:
        return await callback.answer("کاربر یافت نشد!", show_alert=True)
        
    builder = InlineKeyboardBuilder()
    builder.button(text="💰 تغییر موجودی", callback_data=f"edit_balance_{user.telegram_id}")
    builder.button(text="✉️ ارسال پیام", callback_data=f"admin_send_msg_{user.telegram_id}")
    if not user.is_verified:
        builder.button(text="✅ تایید احراز هویت", callback_data=f"approve_kyc_{user.telegram_id}")
    else:
        builder.button(text="🗑 حذف/ریست احراز هویت", callback_data=f"reset_kyc_{user.telegram_id}")
        
    is_blocked = getattr(user, "is_blocked", False)
    block_text = "🔓 رفع مسدودیت" if is_blocked else "🔒 مسدود کردن"
    builder.button(text=block_text, callback_data=f"adm_toggle_block_{user.telegram_id}")
    
    builder.button(text="🔙 بازگشت به مدیریت کاربران", callback_data="admin_manage_user")
    builder.adjust(1)
    
    is_blocked_str = "🔴 مسدود شده" if is_blocked else "🟢 فعال"
    await callback.message.edit_text(
        f"👤 <b>اطلاعات کاربر</b>\n\n"
        f"آیدی: <code>{user.telegram_id}</code>\n"
        f"نام: {user.full_name}\n"
        f"نام کاربری: @{user.username or 'ندارد'}\n"
        f"موجودی: {user.wallet_balance:,.0f} تومان\n"
        f"احراز هویت: {'✅ تایید شده' if user.is_verified else '❌ تایید نشده'}\n"
        f"وضعیت حساب: {is_blocked_str}\n"
        f"تاریخ ثبت‌نام: {user.created_at.strftime('%Y-%m-%d')}",
        reply_markup=builder.as_markup()
    )
    await callback.answer()

@router.callback_query(F.data.startswith("adm_toggle_block_"))
async def adm_toggle_block(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return await callback.answer("عدم دسترسی", show_alert=True)
        
    user_id = int(callback.data.split("_")[3])
    async with AsyncSessionLocal() as session:
        user = await get_user_by_telegram_id(session, user_id)
        if not user:
            return await callback.answer("کاربر یافت نشد!", show_alert=True)
            
        user.is_blocked = not getattr(user, "is_blocked", False)
        new_status = user.is_blocked
        await session.commit()
        
    status_msg = "مسدود شد" if new_status else "رفع مسدودیت شد"
    await callback.answer(f"کاربر با موفقیت {status_msg}", show_alert=True)
    
    # بازنشانی اطلاعات کاربر
    await show_user_detail_by_callback(callback)

@router.callback_query(F.data.startswith("reset_kyc_"))
async def reset_user_kyc(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return await callback.answer("عدم دسترسی", show_alert=True)
        
    user_id = int(callback.data.split("_")[2])
    async with AsyncSessionLocal() as session:
        user = await get_user_by_telegram_id(session, user_id)
        if not user:
            return await callback.answer("کاربر یافت نشد!", show_alert=True)
            
        user.is_verified = False
        user.phone = None
        await session.commit()
        
    await callback.answer("احراز هویت کاربر ریست شد. کاربر دوباره باید احراز هویت کند.", show_alert=True)
    await show_user_detail_by_callback(callback)

def _order_status_emoji(status: str | None) -> str:
    return {
        "completed": "✅",
        "pending": "⏳",
        "pending_payment": "💳",
        "rejected": "❌",
        "refunded": "↩️",
    }.get(status or "", "📦")


def _order_status_label(status: str | None) -> str:
    return {
        "completed": "تکمیل شده",
        "pending": "در انتظار تحویل دستی",
        "pending_payment": "در انتظار پرداخت",
        "rejected": "لغو/ناموفق",
        "refunded": "ریباند شده",
    }.get(status or "", status or "نامشخص")


@router.callback_query(F.data.startswith("admin_manage_orders_"))
async def manage_orders_list(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return
        
    page = int(callback.data.split("_")[3])
    per_page = 10
    
    async with AsyncSessionLocal() as session:
        stmt = select(Order).order_by(Order.id.desc())
        orders = (await session.execute(stmt)).scalars().all()
        
    if not orders:
        builder = InlineKeyboardBuilder()
        builder.button(text="🔙 بازگشت", callback_data="admin_dashboard_back")
        return await callback.message.edit_text(
            "📦 <b>مدیریت سفارش‌ها</b>\n\nهنوز هیچ سفارشی در سیستم ثبت نشده است.",
            reply_markup=builder.as_markup()
        )
        
    total_pages = (len(orders) + per_page - 1) // per_page
    start = (page - 1) * per_page
    end = start + per_page
    current_orders = orders[start:end]
    
    builder = InlineKeyboardBuilder()
    from database.models import Product
    async with AsyncSessionLocal() as session:
        for o in current_orders:
            p = await session.get(Product, o.product_id)
            p_name = p.name if p else "نامشخص"
            status_emoji = _order_status_emoji(o.status)
            builder.button(
                text=f"📦 #{o.id} - {p_name} ({status_emoji})", 
                callback_data=f"adm_ord_det_{o.id}_{page}"
            )
        
    nav_buttons = []
    if page > 1:
        nav_buttons.append(InlineKeyboardButton(text="⬅️ قبلی", callback_data=f"admin_manage_orders_{page-1}"))
    if page < total_pages:
        nav_buttons.append(InlineKeyboardButton(text="بعدی ➡️", callback_data=f"admin_manage_orders_{page+1}"))
        
    builder.adjust(1)
    if nav_buttons:
        builder.row(*nav_buttons)
        
    builder.row(InlineKeyboardButton(text="🔙 بازگشت به داشبورد", callback_data="admin_dashboard_back"))
    
    await callback.message.edit_text(
        f"📦 <b>لیست سفارشات فروشگاه</b> (صفحه {page}/{total_pages})\n\n"
        f"برای مشاهده جزئیات یا تغییر وضعیت هر سفارش روی آن کلیک کنید:",
        reply_markup=builder.as_markup()
    )
    await callback.answer()

@router.callback_query(F.data.startswith("adm_ord_det_"))
async def admin_order_detail(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return
        
    parts = callback.data.split("_")
    order_id = int(parts[3])
    back_page = int(parts[4])
    
    from database.models import Product, User
    async with AsyncSessionLocal() as session:
        o = await session.get(Order, order_id)
        if not o:
            return await callback.answer("سفارش یافت نشد!", show_alert=True)
        u = await session.get(User, o.user_id)
        p = await session.get(Product, o.product_id)
        
    status_text = f"{_order_status_label(o.status)} {_order_status_emoji(o.status)}"
    midasbuy_text = midasbuy_status_label(getattr(o, "midasbuy_status", None))
    checkout_payload = create_checkout_payload(o)
    
    builder = InlineKeyboardBuilder()
    builder.button(text="🔍 استعلام Midasbuy", callback_data=f"adm_ord_midas_check_{o.id}_{back_page}")
    if o.status == "pending_payment":
        builder.button(text="✅ پرداخت موفق و تحویل", callback_data=f"adm_ord_payok_{o.id}_{back_page}", style="success")
        builder.button(text="❌ پرداخت ناموفق", callback_data=f"adm_ord_payfail_{o.id}_{back_page}", style="danger")
    if o.status == "pending":
        builder.button(text="✅ تغییر به تکمیل شده", callback_data=f"adm_ord_set_{o.id}_completed_{back_page}")
        builder.button(text="❌ لغو سفارش (برگشت وجه)", callback_data=f"adm_ord_set_{o.id}_rejected_{back_page}")
    if o.status in ["pending", "completed"]:
        builder.button(text="↩️ ریباند سفارش", callback_data=f"adm_ord_refund_{o.id}_{back_page}", style="danger")
    builder.button(text="🔙 بازگشت به لیست", callback_data=f"admin_manage_orders_{back_page}")
    builder.adjust(1)
    
    await callback.message.edit_text(
        f"📦 <b>جزئیات سفارش شماره #{o.id}</b>\n"
        f"〰️〰️〰️〰️〰️〰️\n"
        f"👤 <b>مشتری:</b> {u.full_name if u else 'نامشخص'} (آیدی: <code>{u.telegram_id if u else 'نامشخص'}</code>)\n"
        f"🛒 <b>محصول:</b> {p.name if p else 'نامشخص'}\n"
        f"💵 <b>مبلغ پرداختی:</b> {o.amount:,.0f} تومان\n"
        f"📅 <b>تاریخ ثبت:</b> {o.created_at.strftime('%Y-%m-%d %H:%M')}\n"
        f"⚡️ <b>وضعیت فعلی:</b> {status_text}\n"
        f"🔎 <b>وضعیت Midasbuy:</b> {midasbuy_text}\n"
        f"🧾 <b>Checkout Ref:</b> <code>{checkout_payload['out_trade_no']}</code>",
        reply_markup=builder.as_markup()
    )
    try:
        await callback.answer()
    except TelegramBadRequest:
        pass

@router.callback_query(F.data.startswith("adm_ord_midas_check_"))
async def admin_order_midas_check(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return

    parts = callback.data.split("_")
    order_id = int(parts[4])
    back_page = int(parts[5])

    async with AsyncSessionLocal() as session:
        order = await session.get(Order, order_id)
        if not order:
            return await callback.answer("سفارش یافت نشد!", show_alert=True)

        query_result = await query_midasbuy_order(
            session,
            order_no=order.midasbuy_order_no,
            out_trade_no=f"bot_order_{order.id}",
        )
        if query_result.get("ok"):
            status = query_result.get("status", "unknown")
            record_midasbuy_event(order, status, query_result.get("data"))
            await session.commit()
            message = f"استعلام انجام شد: {midasbuy_status_label(status)}"
        else:
            message = query_result.get("message") or "استعلام Midasbuy ناموفق بود."

    await callback.answer(message, show_alert=True)
    callback.data = f"adm_ord_det_{order_id}_{back_page}"
    await admin_order_detail(callback)


@router.callback_query(F.data.startswith("adm_ord_payok_"))
async def admin_order_mark_payment_success(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return

    parts = callback.data.split("_")
    order_id = int(parts[3])
    back_page = int(parts[4])

    async with AsyncSessionLocal() as session:
        order = await session.get(Order, order_id)
        if not order or order.status != "pending_payment":
            return await callback.answer("این سفارش در وضعیت انتظار پرداخت نیست.", show_alert=True)

        user = await session.get(User, order.user_id)
        from database.models import Product
        product = await session.get(Product, order.product_id)
        if not user or not product:
            return await callback.answer("کاربر یا محصول سفارش پیدا نشد.", show_alert=True)

        session.add(Transaction(user_id=user.id, amount=order.amount, type="midasbuy_charge"))
        session.add(Transaction(user_id=user.id, amount=-order.amount, type="purchase"))
        await session.flush()
        record_midasbuy_event(order, "paid", {"source": "admin_midasbuy", "status": "paid"})

        from handlers.shop_flow import fulfill_order
        await fulfill_order(session, callback.bot, order, user, product)
        await session.commit()

    await callback.answer("پرداخت موفق ثبت شد و تحویل سفارش اجرا شد.", show_alert=True)
    callback.data = f"adm_ord_det_{order_id}_{back_page}"
    await admin_order_detail(callback)


@router.callback_query(F.data.startswith("adm_ord_payfail_"))
async def admin_order_mark_payment_failed(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return

    parts = callback.data.split("_")
    order_id = int(parts[3])
    back_page = int(parts[4])

    async with AsyncSessionLocal() as session:
        order = await session.get(Order, order_id)
        if not order or order.status != "pending_payment":
            return await callback.answer("این سفارش در وضعیت انتظار پرداخت نیست.", show_alert=True)

        user = await session.get(User, order.user_id)
        order.status = "rejected"
        record_midasbuy_event(order, "payment_failed", {"source": "admin_midasbuy", "status": "payment_failed"})
        await session.commit()

    if user:
        try:
            await callback.bot.send_message(
                chat_id=user.telegram_id,
                text=p_em(f"❌ پرداخت سفارش #{order_id} ناموفق ثبت شد. در صورت کسر وجه با پشتیبانی تماس بگیرید.")
            )
        except Exception:
            pass

    await callback.answer("پرداخت ناموفق ثبت شد.", show_alert=True)
    callback.data = f"adm_ord_det_{order_id}_{back_page}"
    await admin_order_detail(callback)


@router.callback_query(F.data.startswith("adm_ord_refund_"))
async def admin_order_refund(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return

    parts = callback.data.split("_")
    order_id = int(parts[3])
    back_page = int(parts[4])

    async with AsyncSessionLocal() as session:
        order = await session.get(Order, order_id)
        if not order or order.status in ["rejected", "refunded", "pending_payment"]:
            return await callback.answer("برای این سفارش امکان ریباند از این مسیر وجود ندارد.", show_alert=True)

        user = await session.get(User, order.user_id)
        if not user:
            return await callback.answer("کاربر سفارش پیدا نشد.", show_alert=True)

        order.status = "refunded"
        user.wallet_balance += order.amount
        record_midasbuy_event(order, "refunded", {"source": "admin_refund", "status": "refunded"})
        session.add(Transaction(
            user_id=user.id,
            amount=order.amount,
            type="refund_order",
            status="completed",
        ))
        await session.commit()

    try:
        await callback.bot.send_message(
            chat_id=user.telegram_id,
            text=p_em(f"↩️ سفارش #{order_id} ریباند شد و مبلغ {order.amount:,.0f} تومان به کیف پول شما برگشت.")
        )
    except Exception:
        pass

    await callback.answer("ریباند ثبت شد و مبلغ به کیف پول کاربر برگشت.", show_alert=True)
    callback.data = f"adm_ord_det_{order_id}_{back_page}"
    await admin_order_detail(callback)


@router.callback_query(F.data.startswith("adm_ord_set_"))
async def admin_order_set_status(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return
        
    parts = callback.data.split("_")
    order_id = int(parts[3])
    status = parts[4]
    back_page = int(parts[5])
    
    from database.models import User
    async with AsyncSessionLocal() as session:
        o = await session.get(Order, order_id)
        if not o:
            return await callback.answer("سفارش یافت نشد!", show_alert=True)
            
        u = await session.get(User, o.user_id)
        
        if status == "completed" and o.status != "completed":
            o.status = "completed"
            record_midasbuy_event(o, "finished", {"source": "admin_manual_delivery", "status": "finished"})
            await session.commit()
            await callback.answer("سفارش به حالت تکمیل شده تغییر یافت.")
            try:
                await callback.bot.send_message(
                    chat_id=u.telegram_id,
                    text=p_em(f"✅ <b>سفارش انجام شد</b>\nسفارش شما (شماره {order_id}) تکمیل و واریز شد!")
                )
            except:
                pass
                
        elif status == "rejected" and o.status == "pending":
            o.status = "rejected"
            record_midasbuy_event(o, "refunded", {"source": "admin_cancel", "status": "refunded"})
            u.wallet_balance += o.amount
            
            from database.models import Transaction
            new_tx = Transaction(
                user_id=u.id,
                amount=o.amount,
                type="refund_cancelled_order",
                status="completed"
            )
            session.add(new_tx)
            await session.commit()
            
            await callback.answer("سفارش لغو شد و هزینه به کیف پول کاربر بازگشت.")
            try:
                await callback.bot.send_message(
                    chat_id=u.telegram_id,
                    text=p_em(f"❌ <b>سفارش لغو شد</b>\nسفارش شماره {order_id} لغو گردید و مبلغ {o.amount:,.0f} تومان به کیف پول شما برگشت داده شد.")
                )
            except:
                pass
                
    callback.data = f"adm_ord_det_{order_id}_{back_page}"
    await admin_order_detail(callback)


# --- Start text customization handlers ---

@router.callback_query(F.data == "admin_edit_start_text")
async def admin_edit_start_text_menu(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return
        
    builder = InlineKeyboardBuilder()
    builder.button(text="✏️ متن کاربران تایید شده", callback_data="admin_edit_start_verified", style="primary")
    builder.button(text="✏️ متن کاربران تایید نشده", callback_data="admin_edit_start_unverified", style="primary")
    builder.button(text="🔄 ریست به حالت پیش‌فرض", callback_data="admin_reset_start_texts", style="danger")
    builder.button(text="🔙 بازگشت به داشبورد", callback_data="admin_dashboard_back", style="danger")
    builder.adjust(1, 2, 1, 2, 2, 2, 2, 1, 1)
    
    # load current templates
    async with AsyncSessionLocal() as session:
        from handlers.user_panel import DEFAULT_VERIFIED_TPL, DEFAULT_UNVERIFIED_TPL
        verified_text = await get_setting(session, "start_text_verified", DEFAULT_VERIFIED_TPL)
        unverified_text = await get_setting(session, "start_text_unverified", DEFAULT_UNVERIFIED_TPL)
        
    await callback.message.edit_text(
        "⚙️ <b>تنظیمات متن خوش‌آمدگویی (/start)</b>\n\n"
        "در این بخش می‌توانید متن‌هایی که هنگام زدن دستور /start به کاربر نمایش داده می‌شوند را مدیریت کنید.\n\n"
        "📜 <b>متن فعلی کاربران تایید شده:</b>\n"
        f"<pre>{verified_text}</pre>\n\n"
        "📜 <b>متن فعلی کاربران تایید نشده:</b>\n"
        f"<pre>{unverified_text}</pre>\n\n"
        "💡 <b>متغیرهای مجاز جهت استفاده در متن:</b>\n"
        "• <code>{full_name}</code> - نام کامل کاربر\n"
        "• <code>{telegram_id}</code> - آیدی عددی کاربر\n"
        "• <code>{wallet_balance}</code> - موجودی کیف پول کاربر\n"
        "• <code>{greeting}</code> - صبح بخیر/شب بخیر بر اساس ساعت (مخصوص کاربران تایید شده)\n"
        "• <code>{cat_count}</code> - تعداد دسته‌بندی‌ها (مخصوص کاربران تایید شده)\n"
        "• <code>{prod_count}</code> - تعداد محصولات (مخصوص کاربران تایید شده)\n\n"
        "👇 برای ویرایش هر کدام، روی دکمه مربوطه بزنید:",
        reply_markup=builder.as_markup()
    )
    await callback.answer()

@router.callback_query(F.data == "admin_edit_start_verified")
async def admin_edit_start_verified(callback: CallbackQuery, state: FSMContext):
    if callback.from_user.id not in config.admin_ids:
        return
        
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ انصراف", callback_data="admin_edit_start_text", style="danger")
    
    await callback.message.edit_text(
        "📝 <b>ویرایش متن خوش‌آمدگویی (کاربران تایید شده)</b>\n\n"
        "لطفاً متن جدید را ارسال کنید. شما می‌توانید از متغیرهای <code>{full_name}</code>, <code>{telegram_id}</code>, <code>{wallet_balance}</code>, <code>{greeting}</code>, <code>{cat_count}</code>, <code>{prod_count}</code> استفاده کنید.\n\n"
        "⚠️ توجه: از تگ‌های HTML معتبر می‌توانید استفاده کنید.",
        reply_markup=builder.as_markup()
    )
    await state.set_state(AdminState.waiting_for_start_verified)
    await callback.answer()

@router.callback_query(F.data == "admin_edit_start_unverified")
async def admin_edit_start_unverified(callback: CallbackQuery, state: FSMContext):
    if callback.from_user.id not in config.admin_ids:
        return
        
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ انصراف", callback_data="admin_edit_start_text", style="danger")
    
    await callback.message.edit_text(
        "📝 <b>ویرایش متن خوش‌آمدگویی (کاربران تایید نشده)</b>\n\n"
        "لطفاً متن جدید را ارسال کنید. شما می‌توانید از متغیرهای <code>{full_name}</code>, <code>{telegram_id}</code> استفاده کنید.\n\n"
        "⚠️ توجه: از تگ‌های HTML معتبر می‌توانید استفاده کنید.",
        reply_markup=builder.as_markup()
    )
    await state.set_state(AdminState.waiting_for_start_unverified)
    await callback.answer()

@router.message(AdminState.waiting_for_start_verified)
async def process_start_verified(message: Message, state: FSMContext):
    if message.from_user.id not in config.admin_ids:
        return
        
    new_text = message.text
    async with AsyncSessionLocal() as session:
        await set_setting(session, "start_text_verified", new_text)
        
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت به تنظیمات", callback_data="admin_edit_start_text", style="primary")
    await message.answer("✅ متن خوش‌آمدگویی کاربران تایید شده با موفقیت به‌روزرسانی شد.", reply_markup=builder.as_markup())
    await state.clear()

@router.message(AdminState.waiting_for_start_unverified)
async def process_start_unverified(message: Message, state: FSMContext):
    if message.from_user.id not in config.admin_ids:
        return
        
    new_text = message.text
    async with AsyncSessionLocal() as session:
        await set_setting(session, "start_text_unverified", new_text)
        
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت به تنظیمات", callback_data="admin_edit_start_text", style="primary")
    await message.answer("✅ متن خوش‌آمدگویی کاربران غیر احراز هویت شده با موفقیت به‌روزرسانی شد.", reply_markup=builder.as_markup())
    await state.clear()

@router.callback_query(F.data == "admin_reset_start_texts")
async def admin_reset_start_texts(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return
        
    from handlers.user_panel import DEFAULT_VERIFIED_TPL, DEFAULT_UNVERIFIED_TPL
    async with AsyncSessionLocal() as session:
        await set_setting(session, "start_text_verified", DEFAULT_VERIFIED_TPL)
        await set_setting(session, "start_text_unverified", DEFAULT_UNVERIFIED_TPL)
        
    await callback.answer("✅ textها به حالت پیش‌فرض ریست شدند.", show_alert=True)
    await admin_edit_start_text_menu(callback)


# --- تنظیمات سیستم ربات ---

@router.callback_query(F.data == "admin_bot_settings")
async def admin_bot_settings_menu(callback: CallbackQuery, state: FSMContext = None):
    if state:
        await state.clear()
    async with AsyncSessionLocal() as session:
        if not await ensure_runtime_admin(session, callback.from_user.id):
            return
        
    async with AsyncSessionLocal() as session:
        bot_enabled = await get_setting(session, "bot_enabled", "true")
        kyc_required = await get_setting(session, "kyc_required", "false")
        zibal_enabled = await get_setting(session, "zibal_enabled", "true")
        nowpayments_enabled = await get_setting(session, "nowpayments_enabled", "true")
        group_kyc = await get_setting(session, "group_kyc", str(config.admin_group_id))
        group_orders = await get_setting(session, "group_orders", str(config.fulfillment_group_id))
        group_receipts = await get_setting(session, "group_receipts", str(config.admin_group_id))
        zibal_merchant = await get_setting(session, "zibal_merchant", "zibal")
        nowpayments_api_key = await get_setting(session, "nowpayments_api_key", "")
        usdt_rate = await get_setting(session, "usdt_rate", "60000")
        card_number = await get_setting(session, "card_number", "تنظیم نشده")
        card_name = await get_setting(session, "card_name", "تنظیم نشده")
        support_id = await get_setting(session, "support_id", "Support")
        mandatory_join_ids = await get_setting(session, "mandatory_join_ids", "")
        mandatory_join_links = await get_setting(session, "mandatory_join_links", "")
        
    builder = InlineKeyboardBuilder()
    
    # دکمه خاموش/روشن
    status_text = "🟢 روشن (فعال)" if bot_enabled == "true" else "🔴 خاموش (تعمیرات)"
    kyc_status = "🟢 فعال (اجباری)" if kyc_required == "true" else "🔴 غیرفعال (اختیاری)"
    zibal_status = "🟢 فعال" if zibal_enabled == "true" else "🔴 غیرفعال"
    nowpayments_status = "🟢 فعال" if nowpayments_enabled == "true" else "🔴 غیرفعال"
    nowpayments_key_text = "تنظیم شده" if nowpayments_api_key else "تنظیم نشده"
    
    builder.button(text=f"وضعیت ربات: {status_text}", callback_data="admin_toggle_bot")
    builder.button(text=f"احراز هویت: {kyc_status}", callback_data="admin_toggle_kyc")
    builder.button(text=f"زیبال: {zibal_status}", callback_data="admin_toggle_zibal")
    builder.button(text=f"نوپیمنتز: {nowpayments_status}", callback_data="admin_toggle_nowpayments")
    
    # دکمه‌های ویرایش گروه
    builder.button(text="👥 تنظیم گروه احراز هویت", callback_data="admin_set_grp_kyc")
    builder.button(text="👥 تنظیم گروه سفارش‌ها", callback_data="admin_set_grp_orders")
    builder.button(text="👥 تنظیم گروه فیش‌ها", callback_data="admin_set_grp_receipts")
    
    # مرچنت زیبال
    builder.button(text="💳 تنظیم مرچنت زیبال", callback_data="admin_set_zibal")
    builder.button(text="💳 تنظیم شماره کارت", callback_data="admin_set_card_number")
    builder.button(text="👤 تنظیم نام صاحب کارت", callback_data="admin_set_card_name")
    builder.button(text="🪙 تنظیم API نوپیمنتز", callback_data="admin_set_nowpayments_api")
    builder.button(text="💵 تنظیم نرخ تتر", callback_data="admin_set_usdt_rate")
    builder.button(text="👑 مدیریت ادمین‌ها", callback_data="admin_manage_admins")
    builder.button(text="🧑‍💻 تنظیم آیدی پشتیبانی", callback_data="admin_set_support_id")
    
    # عضویت اجباری
    builder.button(text="📢 کانال‌های عضویت اجباری", callback_data="admin_set_mandatory_channels")
    builder.button(text="✨ تنظیم کاستوم ایموجی‌ها", callback_data="admin_emoji_settings_1")
    builder.button(text="⚙️ تنظیم API کلاب (میداس‌بای)", callback_data="admin_set_midasbuy_api")
    
    # بازگشت
    builder.button(text="🔙 بازگشت به داشبورد", callback_data="admin_dashboard_back", style="danger")
    builder.adjust(2, 2, 1, 2, 3, 2, 2, 1, 1, 1, 1)
    
    settings_text = (
        f"🛠 <b>تنظیمات سیستم ربات</b>\n"
        f"〰️〰️〰️〰️〰️〰️〰️\n\n"
        f"🤖 <b>وضعیت ربات:</b> {status_text}\n"
        f"🔒 <b>احراز هویت کاربران:</b> {kyc_status}\n"
        f"💳 <b>وضعیت زیبال:</b> {zibal_status}\n"
        f"🔑 <b>مرچنت زیبال:</b> <code>{zibal_merchant}</code>\n\n"
        f"🪙 <b>وضعیت نوپیمنتز:</b> {nowpayments_status} ({nowpayments_key_text})\n"
        f"💵 <b>نرخ تتر (تومان):</b> <code>{usdt_rate}</code>\n"
        f"⚙️ <b>وضعیت API کلاب (میداس‌بای):</b> تنظیم شده\n"
        f"💳 <b>شماره کارت:</b> <code>{card_number}</code>\n"
        f"👤 <b>نام صاحب کارت:</b> {card_name}\n"
        f"🧑‍💻 <b>آیدی پشتیبانی:</b> <code>{support_id}</code>\n\n"
        f"👥 <b>کانال/گروه احراز هویت:</b> <code>{group_kyc}</code>\n"
        f"👥 <b>کانال/گروه واریز سفارشات:</b> <code>{group_orders}</code>\n"
        f"👥 <b>کانال/گروه تایید فیش‌ها:</b> <code>{group_receipts}</code>\n\n"
        f"📢 <b>کانال‌های عضویت اجباری (آیدی‌ها):</b> <code>{mandatory_join_ids or 'غیرفعال'}</code>\n"
        f"🔗 <b>لینک‌های عضویت اجباری:</b> <code>{mandatory_join_links or 'تنظیم نشده'}</code>\n\n"
        f"✨ <b>کاستوم ایموجی‌ها:</b> قابل تنظیم توسط ادمین\n\n"
        f"👇 جهت تغییر هر یک از موارد فوق روی دکمه مربوطه کلیک کنید:"
    )
    
    await callback.message.edit_text(settings_text, reply_markup=builder.as_markup())
    await callback.answer()

@router.callback_query(F.data.startswith("admin_emoji_settings_"))
async def admin_emoji_settings_menu(callback: CallbackQuery, state: FSMContext = None):
    if state:
        await state.clear()
    async with AsyncSessionLocal() as session:
        if not await ensure_runtime_admin(session, callback.from_user.id):
            return

    try:
        page = int(callback.data.split("_")[-1])
    except ValueError:
        page = 1
    total_pages = max(1, (len(ADMIN_EMOJI_ITEMS) + EMOJI_PAGE_SIZE - 1) // EMOJI_PAGE_SIZE)
    page = max(1, min(page, total_pages))
    start = (page - 1) * EMOJI_PAGE_SIZE
    current_items = ADMIN_EMOJI_ITEMS[start:start + EMOJI_PAGE_SIZE]
    overrides = get_custom_emoji_overrides()

    builder = InlineKeyboardBuilder()
    for offset, emoji in enumerate(current_items):
        idx = start + offset
        custom_id = overrides.get(emoji)
        display_id = f"➔ {custom_id}" if custom_id else "(پیش‌فرض)"
        builder.button(
            text=f"{idx + 1}. {emoji} {display_id}",
            callback_data=f"admin_emoji_edit_{idx}_{page}"
        )

    builder.adjust(1)
    nav = []
    if page > 1:
        nav.append(InlineKeyboardButton(text="قبلی", callback_data=f"admin_emoji_settings_{page - 1}"))
    if page < total_pages:
        nav.append(InlineKeyboardButton(text="بعدی", callback_data=f"admin_emoji_settings_{page + 1}"))
    if nav:
        builder.row(*nav)
    builder.row(
        InlineKeyboardButton(text="تنظیم گروهی", callback_data="admin_emoji_bulk"),
        InlineKeyboardButton(text="ریست همه", callback_data="admin_emoji_reset_all")
    )
    builder.row(InlineKeyboardButton(text="بازگشت به تنظیمات", callback_data="admin_bot_settings"))

    text = (
        f"<b>تنظیم کاستوم ایموجی‌ها</b> (صفحه {page}/{total_pages})\n"
        f"〰️〰️〰️〰️〰️〰️〰️\n\n"
        f"در این صفحه ایموجی‌ها به شکل استاندارد تلگرام نمایش داده می‌شوند.\n"
        f"برای تغییر هر ایموجی روی دکمه آن کلیک کنید.\n\n"
        f"مواردی که با علامت ➔ مشخص شده‌اند دارای تنظیم اختصاصی هستند."
    )
    try:
        await callback.message.edit_text(text, reply_markup=builder.as_markup())
    except TelegramBadRequest as e:
        if "message is not modified" not in str(e):
            raise
    await callback.answer()

@router.callback_query(F.data.startswith("admin_emoji_edit_"))
async def admin_emoji_edit_prompt(callback: CallbackQuery, state: FSMContext):
    if callback.from_user.id not in config.admin_ids:
        return
    parts = callback.data.split("_")
    idx = int(parts[3])
    page = int(parts[4])
    if idx < 0 or idx >= len(ADMIN_EMOJI_ITEMS):
        return await callback.answer("ایموجی نامعتبر است.", show_alert=True)

    emoji = ADMIN_EMOJI_ITEMS[idx]
    overrides = get_custom_emoji_overrides()
    current_id = get_effective_emoji_id(emoji) or "ندارد"
    custom_id = overrides.get(emoji)

    await state.update_data(edit_emoji=emoji, edit_emoji_page=page)
    builder = InlineKeyboardBuilder()
    if custom_id:
        builder.button(text="🔄 بازنشانی به پیش‌فرض", callback_data=f"admin_emoji_reset_{idx}_{page}")
    builder.button(text="🔙 انصراف", callback_data=f"admin_emoji_settings_{page}")
    builder.adjust(1)

    await callback.message.edit_text(
        (
            f"✨ <b>تنظیم ایموجی {emoji}</b>\n\n"
            f"🏷 ایموجی استاندارد: {emoji}\n"
            f"🆔 شناسه فعلی: <code>{current_id}</code>\n"
            f"🆔 شناسه اختصاصی ادمین: <code>{custom_id or 'تنظیم نشده (پیش‌فرض)'}</code>\n\n"
            f"👇 برای ویرایش، لطفاً ایموجی پرمیوم جدید را ارسال کنید (یا آیدی عددی آن را بنویسید):\n"
            f"یا می‌توانید دکمه بازنشانی را بزنید. برای حذف تنظیم اختصاصی می‌توانید عبارت reset را بفرستید."
        ),
        reply_markup=builder.as_markup()
    )
    await state.set_state(AdminState.waiting_for_custom_emoji_id)
    await callback.answer()

@router.message(AdminState.waiting_for_custom_emoji_id)
async def process_custom_emoji_id(message: Message, state: FSMContext):
    if message.from_user.id not in config.admin_ids:
        return
    data = await state.get_data()
    emoji = data.get("edit_emoji")
    page = int(data.get("edit_emoji_page", 1))
    val = ""
    entities = message.entities or message.caption_entities
    if entities:
        for entity in entities:
            if entity.type == "custom_emoji" and entity.custom_emoji_id:
                val = entity.custom_emoji_id
                break
    if not val:
        val = (message.text or message.caption or "").strip()
    overrides = get_custom_emoji_overrides()

    if val.lower() in {"reset", "none", "delete", "حذف", "ریست"}:
        overrides.pop(emoji, None)
    elif _valid_custom_emoji_id(val):
        overrides[emoji] = val
    else:
        return await message.answer("⚠️ مقدار معتبر نیست. فقط custom_emoji_id عددی را ارسال کنید یا reset بفرستید:")

    set_custom_emoji_overrides(overrides)
    async with AsyncSessionLocal() as session:
        await set_setting(session, CUSTOM_EMOJI_SETTING_KEY, json.dumps(overrides, ensure_ascii=False))

    await state.clear()
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت به تنظیم ایموجی‌ها", callback_data=f"admin_emoji_settings_{page}")
    await message.answer(
        f"✅ تنظیم ایموجی {emoji} با موفقیت ذخیره شد.\n\n"
        f"🏷 ایموجی استاندارد: {emoji}\n"
        f"🆔 شناسه نهایی: <code>{get_effective_emoji_id(emoji) or 'ندارد'}</code>",
        reply_markup=builder.as_markup()
    )

@router.callback_query(F.data.regexp(r"^admin_emoji_reset_\d+_\d+$"))
async def admin_emoji_reset_one(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return
    parts = callback.data.split("_")
    idx = int(parts[3])
    page = int(parts[4])
    emoji = ADMIN_EMOJI_ITEMS[idx]
    overrides = get_custom_emoji_overrides()
    overrides.pop(emoji, None)
    set_custom_emoji_overrides(overrides)
    async with AsyncSessionLocal() as session:
        await set_setting(session, CUSTOM_EMOJI_SETTING_KEY, json.dumps(overrides, ensure_ascii=False))
    await callback.answer("تنظیم اختصاصی این ایموجی حذف شد.", show_alert=True)
    await admin_emoji_settings_menu(callback)

@router.callback_query(F.data == "admin_emoji_reset_all")
async def admin_emoji_reset_all(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return
    set_custom_emoji_overrides({})
    async with AsyncSessionLocal() as session:
        await set_setting(session, CUSTOM_EMOJI_SETTING_KEY, "{}")
    await callback.answer("همه تنظیمات اختصاصی ایموجی حذف شد.", show_alert=True)
    await admin_emoji_settings_menu(callback)

@router.callback_query(F.data == "admin_emoji_bulk")
async def admin_emoji_bulk_prompt(callback: CallbackQuery, state: FSMContext):
    if callback.from_user.id not in config.admin_ids:
        return
    builder = InlineKeyboardBuilder()
    builder.button(text="انصراف", callback_data="admin_emoji_settings_1")
    await callback.message.edit_text(
        (
            "<b>تنظیم گروهی کاستوم ایموجی</b>\n\n"
            "یکی از این فرمت‌ها را ارسال کنید:\n\n"
            "<code>{\"✅\":\"1234567890123456789\",\"❌\":\"1234567890123456789\"}</code>\n\n"
            "یا هر خط یک مورد:\n"
            "<code>✅ 1234567890123456789\n❌ 1234567890123456789</code>\n\n"
            "برای حذف همه تنظیمات اختصاصی عبارت <code>reset_all</code> را ارسال کنید."
        ),
        reply_markup=builder.as_markup()
    )
    await state.set_state(AdminState.waiting_for_custom_emoji_bulk)
    await callback.answer()

@router.message(AdminState.waiting_for_custom_emoji_bulk)
async def process_custom_emoji_bulk(message: Message, state: FSMContext):
    if message.from_user.id not in config.admin_ids:
        return
    raw = (message.text or message.caption or "").strip()
    if not raw:
        return await message.answer("⚠️ متن خالی است. دوباره ارسال کنید:")

    if raw.lower() in {"reset_all", "reset", "پاک کردن همه"}:
        overrides = {}
    else:
        try:
            parsed = json.loads(raw)
            if not isinstance(parsed, dict):
                parsed = {}
        except Exception:
            parsed = {}
            entities = message.entities or message.caption_entities or []
            
            current_utf16_offset = 0
            for line in raw.splitlines(keepends=True):
                line_len_utf16 = len(line.encode('utf-16-le')) // 2
                start_utf16 = current_utf16_offset
                end_utf16 = current_utf16_offset + line_len_utf16
                current_utf16_offset = end_utf16
                
                line_text = line.strip()
                if not line_text:
                    continue
                
                # Check for custom emoji entity on this line
                line_custom_emoji_id = None
                for entity in entities:
                    if entity.type == "custom_emoji" and entity.custom_emoji_id:
                        if start_utf16 <= entity.offset < end_utf16:
                            line_custom_emoji_id = entity.custom_emoji_id
                            break
                
                # Find standard emoji character on this line
                found_emoji = None
                for emoji in sorted(BASE_EMOJI_ID_MAPPING.keys(), key=len, reverse=True):
                    if emoji in line_text:
                        found_emoji = emoji
                        break
                
                if found_emoji:
                    if line_custom_emoji_id:
                        parsed[found_emoji] = line_custom_emoji_id
                    else:
                        match = __import__("re").search(r"(\d{10,})", line_text)
                        if match:
                            parsed[found_emoji] = match.group(1)

        overrides = get_custom_emoji_overrides()
        for emoji, emoji_id in parsed.items():
            if _valid_custom_emoji_id(str(emoji_id)):
                overrides[str(emoji)] = str(emoji_id).strip()

    set_custom_emoji_overrides(overrides)
    async with AsyncSessionLocal() as session:
        await set_setting(session, CUSTOM_EMOJI_SETTING_KEY, json.dumps(overrides, ensure_ascii=False))

    await state.clear()
    builder = InlineKeyboardBuilder()
    builder.button(text="بازگشت به تنظیم ایموجی‌ها", callback_data="admin_emoji_settings_1")
    await message.answer(
        f"تنظیمات گروهی ذخیره شد.\nتعداد ایموجی‌های اختصاصی: <b>{len(overrides)}</b>",
        reply_markup=builder.as_markup()
    )

@router.callback_query(F.data == "admin_toggle_bot")
async def admin_toggle_bot(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return
        
    async with AsyncSessionLocal() as session:
        current = await get_setting(session, "bot_enabled", "true")
        new_status = "false" if current == "true" else "true"
        await set_setting(session, "bot_enabled", new_status)
        
    await callback.answer("وضعیت ربات تغییر یافت", show_alert=True)
    await admin_bot_settings_menu(callback)

@router.callback_query(F.data == "admin_toggle_kyc")
async def admin_toggle_kyc(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return
        
    async with AsyncSessionLocal() as session:
        current = await get_setting(session, "kyc_required", "false")
        new_status = "false" if current == "true" else "true"
        await set_setting(session, "kyc_required", new_status)
        
    await callback.answer("وضعیت احراز هویت تغییر یافت", show_alert=True)
    await admin_bot_settings_menu(callback)

@router.callback_query(F.data == "admin_toggle_zibal")
async def admin_toggle_zibal(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return
        
    async with AsyncSessionLocal() as session:
        current = await get_setting(session, "zibal_enabled", "true")
        new_status = "false" if current == "true" else "true"
        await set_setting(session, "zibal_enabled", new_status)
        
    await callback.answer("وضعیت زیبال تغییر یافت", show_alert=True)
    await admin_bot_settings_menu(callback)

@router.callback_query(F.data == "admin_toggle_nowpayments")
async def admin_toggle_nowpayments(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return
        
    async with AsyncSessionLocal() as session:
        current = await get_setting(session, "nowpayments_enabled", "true")
        new_status = "false" if current == "true" else "true"
        await set_setting(session, "nowpayments_enabled", new_status)
        
    await callback.answer("وضعیت نوپیمنتز تغییر یافت", show_alert=True)
    await admin_bot_settings_menu(callback)

@router.callback_query(F.data == "admin_set_card_number")
async def admin_set_card_number_prompt(callback: CallbackQuery, state: FSMContext):
    if callback.from_user.id not in config.admin_ids:
        return
        
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ انصراف", callback_data="admin_bot_settings")
    await callback.message.edit_text(
        "💳 <b>تنظیم شماره کارت</b>\n\n"
        "شماره کارت مقصد واریز را ارسال کنید:",
        reply_markup=builder.as_markup()
    )
    await state.set_state(AdminState.waiting_for_card_number)
    await callback.answer()

@router.message(AdminState.waiting_for_card_number)
async def process_set_card_number(message: Message, state: FSMContext):
    if message.from_user.id not in config.admin_ids:
        return
    val = message.text.strip()
    if len(val.replace("-", "").replace(" ", "")) < 12:
        return await message.answer("⚠️ شماره کارت معتبر نیست. لطفاً مجدداً ارسال کنید:")
        
    async with AsyncSessionLocal() as session:
        await set_setting(session, "card_number", val)
        
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت به تنظیمات", callback_data="admin_bot_settings")
    await message.answer(f"✅ شماره کارت با موفقیت به <code>{val}</code> تغییر یافت.", reply_markup=builder.as_markup())
    await state.clear()

@router.callback_query(F.data == "admin_set_card_name")
async def admin_set_card_name_prompt(callback: CallbackQuery, state: FSMContext):
    if callback.from_user.id not in config.admin_ids:
        return
        
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ انصراف", callback_data="admin_bot_settings")
    await callback.message.edit_text(
        "👤 <b>تنظیم نام صاحب کارت</b>\n\n"
        "نام صاحب کارت را ارسال کنید:",
        reply_markup=builder.as_markup()
    )
    await state.set_state(AdminState.waiting_for_card_name)
    await callback.answer()

@router.message(AdminState.waiting_for_card_name)
async def process_set_card_name(message: Message, state: FSMContext):
    if message.from_user.id not in config.admin_ids:
        return
    val = message.text.strip()
    if len(val) < 2:
        return await message.answer("⚠️ نام خیلی کوتاه است. لطفاً مجدداً ارسال کنید:")
        
    async with AsyncSessionLocal() as session:
        await set_setting(session, "card_name", val)
        
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت به تنظیمات", callback_data="admin_bot_settings")
    await message.answer(f"✅ نام صاحب کارت با موفقیت به <b>{val}</b> تغییر یافت.", reply_markup=builder.as_markup())
    await state.clear()

@router.callback_query(F.data == "admin_set_nowpayments_api")
async def admin_set_nowpayments_api_prompt(callback: CallbackQuery, state: FSMContext):
    if callback.from_user.id not in config.admin_ids:
        return
        
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ انصراف", callback_data="admin_bot_settings")
    await callback.message.edit_text(
        "🪙 <b>تنظیم API Key نوپیمنتز</b>\n\n"
        "API Key حساب NOWPayments را ارسال کنید:",
        reply_markup=builder.as_markup()
    )
    await state.set_state(AdminState.waiting_for_nowpayments_api_key)
    await callback.answer()

@router.message(AdminState.waiting_for_nowpayments_api_key)
async def process_set_nowpayments_api(message: Message, state: FSMContext):
    if message.from_user.id not in config.admin_ids:
        return
    val = message.text.strip()
    if len(val) < 10:
        return await message.answer("⚠️ API Key خیلی کوتاه است. لطفاً مجدداً ارسال کنید:")
        
    async with AsyncSessionLocal() as session:
        await set_setting(session, "nowpayments_api_key", val)
        
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت به تنظیمات", callback_data="admin_bot_settings")
    await message.answer("✅ API Key نوپیمنتز با موفقیت ذخیره شد.", reply_markup=builder.as_markup())
    await state.clear()


@router.message(AdminState.waiting_for_new_admin_id)
async def process_add_admin(message: Message, state: FSMContext):
    if message.from_user.id not in config.admin_ids:
        return
    val = message.text.strip()
    if not val.isdigit():
        return await message.answer("⚠️ لطفاً فقط آیدی عددی تلگرام را ارسال کنید:")
        
    admin_id = int(val)
    async with AsyncSessionLocal() as session:
        await set_user_admin(session, admin_id)
        
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 مدیریت ادمین‌ها", callback_data="admin_manage_admins")
    await message.answer(f"✅ کاربر <code>{admin_id}</code> به ادمین‌ها اضافه شد.", reply_markup=builder.as_markup())
    await state.clear()

@router.callback_query(F.data == "admin_manage_admins")
async def admin_manage_admins(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return

    primary_admins = set(getattr(config, "primary_admin_ids", config.admin_ids))
    async with AsyncSessionLocal() as session:
        db_admins = await get_database_admin_users(session)

    builder = InlineKeyboardBuilder()
    text = (
        "👑 <b>مدیریت ادمین‌ها</b>\n"
        "〰️〰️〰️〰️〰️〰️〰️\n\n"
        "از این بخش می‌توانید ادمین جدید اضافه کنید یا ادمین‌های اضافه‌شده از پنل را حذف کنید.\n\n"
    )

    if primary_admins:
        text += "🔒 <b>ادمین‌های اصلی قابل حذف نیستند:</b>\n"
        for admin_id in sorted(primary_admins):
            text += f"• <code>{admin_id}</code>\n"
        text += "\n"

    removable_admins = [u for u in db_admins if u.telegram_id not in primary_admins]
    if removable_admins:
        text += "🗑 <b>ادمین‌های قابل حذف:</b>\n"
        for user in removable_admins:
            label = user.full_name or user.username or str(user.telegram_id)
            text += f"• {label} - <code>{user.telegram_id}</code>\n"
            builder.button(
                text=f"🗑 حذف {user.telegram_id}",
                callback_data=f"admin_remove_admin_{user.telegram_id}"
            )
    else:
        text += "هیچ ادمین قابل حذفی از پنل اضافه نشده است.\n"

    builder.button(text="👑 افزودن ادمین", callback_data="admin_add_admin_prompt")
    builder.button(text="🔙 بازگشت به تنظیمات", callback_data="admin_bot_settings")
    builder.adjust(1)

    await callback.message.edit_text(p_em(text), reply_markup=builder.as_markup())
    await callback.answer()

@router.callback_query(F.data.startswith("admin_remove_admin_"))
async def admin_remove_admin(callback: CallbackQuery):
    if callback.from_user.id not in config.admin_ids:
        return

    admin_id = int(callback.data.rsplit("_", 1)[1])
    if admin_id == callback.from_user.id:
        return await callback.answer("نمی‌توانید دسترسی ادمین خودتان را حذف کنید.", show_alert=True)

    async with AsyncSessionLocal() as session:
        removed = await remove_user_admin(session, admin_id)

    if removed:
        await callback.answer("ادمین حذف شد.", show_alert=True)
    else:
        await callback.answer("این ادمین اصلی است یا قابل حذف نیست.", show_alert=True)
    await admin_manage_admins(callback)


@router.callback_query(F.data == "admin_add_admin_prompt")
async def admin_add_admin_prompt(callback: CallbackQuery, state: FSMContext):
    if callback.from_user.id not in config.admin_ids:
        return
        
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 انصراف", callback_data="admin_bot_settings")
    
    await state.set_state(AdminState.waiting_for_new_admin_id)
    await callback.message.edit_text(
        p_em("👤 لطفاً **آیدی عددی (Telegram ID)** کاربری که می‌خواهید ادمین شود را ارسال کنید:\n\n(کاربر حتماً باید حداقل یک‌بار ربات را استارت کرده باشد)"),
        reply_markup=builder.as_markup()
    )
    await callback.answer()

@router.message(AdminState.waiting_for_new_admin_id)
async def process_admin_add_admin(message: Message, state: FSMContext):
    if message.from_user.id not in config.admin_ids:
        return
        
    if not message.text or not message.text.isdigit():
        builder = InlineKeyboardBuilder()
        builder.button(text="🔙 انصراف", callback_data="admin_bot_settings")
        return await message.answer("❌ خطا: آیدی تلگرام باید فقط شامل اعداد باشد.", reply_markup=builder.as_markup())
        
    new_admin_id = int(message.text)
    
    async with AsyncSessionLocal() as session:
        success = await set_user_admin(session, new_admin_id)
        
    await state.clear()
    
    if success:
        await admin_dashboard(message, prefix_text=f"✅ کاربر با آیدی <code>{new_admin_id}</code> با موفقیت ادمین شد.\n\n")
    else:
        builder = InlineKeyboardBuilder()
        builder.button(text="🔙 بازگشت به تنظیمات", callback_data="admin_bot_settings")
        await message.answer(
            f"❌ نتوانستم کاربر را ادمین کنم.\nشاید این کاربر هنوز عضو ربات نشده است (باید /start بزند).",
            reply_markup=builder.as_markup()
        )

@router.callback_query(F.data == "admin_set_support_id")
async def admin_set_support_id_prompt(callback: CallbackQuery, state: FSMContext):
    if callback.from_user.id not in config.admin_ids:
        return
        
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ انصراف", callback_data="admin_bot_settings")
    await callback.message.edit_text(
        "🧑‍💻 <b>تنظیم آیدی پشتیبانی</b>\n\n"
        "آیدی پشتیبانی را بدون @ یا همراه @ ارسال کنید. مثال: <code>MySupport</code>",
        reply_markup=builder.as_markup()
    )
    await state.set_state(AdminState.waiting_for_support_id)
    await callback.answer()

@router.message(AdminState.waiting_for_support_id)
async def process_set_support_id(message: Message, state: FSMContext):
    if message.from_user.id not in config.admin_ids:
        return
    val = message.text.strip().replace("https://t.me/", "").replace("http://t.me/", "").lstrip("@")
    if len(val) < 3:
        return await message.answer("⚠️ آیدی پشتیبانی معتبر نیست. لطفاً مجدداً ارسال کنید:")
        
    async with AsyncSessionLocal() as session:
        await set_setting(session, "support_id", val)
        
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت به تنظیمات", callback_data="admin_bot_settings")
    await message.answer(f"✅ آیدی پشتیبانی با موفقیت به <code>@{val}</code> تغییر یافت.", reply_markup=builder.as_markup())
    await state.clear()

@router.callback_query(F.data.startswith("admin_set_grp_"))
async def admin_set_group_prompt(callback: CallbackQuery, state: FSMContext):
    if callback.from_user.id not in config.admin_ids:
        return
        
    gtype = callback.data.split("_")[3] # kyc, orders, receipts
    await state.update_data(edit_group_type=gtype)
    
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ انصراف", callback_data="admin_bot_settings")
    
    titles = {
        "kyc": "گروه احراز هویت",
        "orders": "گروه واریز سفارشات",
        "receipts": "گروه تایید فیش‌ها"
    }
    
    await callback.message.edit_text(
        f"👥 <b>تنظیم آیدی عددی {titles[gtype]}</b>\n\n"
        f"لطفاً آیدی عددی کانال یا گروه مورد نظر خود را ارسال کنید (همراه با علامت منفی، مثلاً -100123456789):",
        reply_markup=builder.as_markup()
    )
    
    if gtype == "kyc":
        await state.set_state(AdminState.waiting_for_group_kyc)
    elif gtype == "orders":
        await state.set_state(AdminState.waiting_for_group_orders)
    elif gtype == "receipts":
        await state.set_state(AdminState.waiting_for_group_receipts)
        
    await callback.answer()

@router.message(AdminState.waiting_for_group_kyc)
async def process_set_group_kyc(message: Message, state: FSMContext):
    if message.from_user.id not in config.admin_ids:
        return
    val = message.text.strip()
    if not val.lstrip("-").isdigit():
        return await message.answer("⚠️ آیدی وارد شده معتبر نیست. لطفاً یک آیدی عددی معتبر (مانند -100xxxx) ارسال کنید.")
        
    async with AsyncSessionLocal() as session:
        await set_setting(session, "group_kyc", val)
        
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت به تنظیمات", callback_data="admin_bot_settings")
    await message.answer(f"✅ آیدی گروه احراز هویت با موفقیت به <code>{val}</code> تغییر یافت.", reply_markup=builder.as_markup())
    await state.clear()

@router.message(AdminState.waiting_for_group_orders)
async def process_set_group_orders(message: Message, state: FSMContext):
    if message.from_user.id not in config.admin_ids:
        return
    val = message.text.strip()
    if not val.lstrip("-").isdigit():
        return await message.answer("⚠️ آیدی وارد شده معتبر نیست. لطفاً یک آیدی عددی معتبر ارسال کنید.")
        
    async with AsyncSessionLocal() as session:
        await set_setting(session, "group_orders", val)
        
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت به تنظیمات", callback_data="admin_bot_settings")
    await message.answer(f"✅ آیدی گروه سفارش‌ها با موفقیت به <code>{val}</code> تغییر یافت.", reply_markup=builder.as_markup())
    await state.clear()

@router.message(AdminState.waiting_for_group_receipts)
async def process_set_group_receipts(message: Message, state: FSMContext):
    if message.from_user.id not in config.admin_ids:
        return
    val = message.text.strip()
    if not val.lstrip("-").isdigit():
        return await message.answer("⚠️ آیدی وارد شده معتبر نیست. لطفاً یک آیدی عددی معتبر ارسال کنید.")
        
    async with AsyncSessionLocal() as session:
        await set_setting(session, "group_receipts", val)
        
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت به تنظیمات", callback_data="admin_bot_settings")
    await message.answer(f"✅ آیدی گروه تایید فیش‌ها با موفقیت به <code>{val}</code> تغییر یافت.", reply_markup=builder.as_markup())
    await state.clear()

@router.callback_query(F.data == "admin_set_zibal")
async def admin_set_zibal_prompt(callback: CallbackQuery, state: FSMContext):
    if callback.from_user.id not in config.admin_ids:
        return
        
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ انصراف", callback_data="admin_bot_settings")
    
    await callback.message.edit_text(
        f"💳 <b>تنظیم مرچنت کد زیبال (Merchant ID)</b>\n\n"
        f"لطفاً کد درگاه پرداخت زیبال خود را ارسال کنید (برای تست می‌توانید عبارت zibal را ارسال کنید):",
        reply_markup=builder.as_markup()
    )
    await state.set_state(AdminState.waiting_for_zibal_merchant)
    await callback.answer()

@router.message(AdminState.waiting_for_zibal_merchant)
async def process_set_zibal_merchant(message: Message, state: FSMContext):
    if message.from_user.id not in config.admin_ids:
        return
    val = message.text.strip()
    if len(val) < 4:
        return await message.answer("⚠️ کد مرچنت خیلی کوتاه است. لطفاً مجدداً ارسال کنید:")
        
    async with AsyncSessionLocal() as session:
        await set_setting(session, "zibal_merchant", val)
        
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت به تنظیمات", callback_data="admin_bot_settings")
    await message.answer(f"✅ مرچنت کد زیبال با موفقیت به <code>{val}</code> تغییر یافت.", reply_markup=builder.as_markup())
    await state.clear()


# --- تنظیمات عضویت اجباری ---

@router.callback_query(F.data == "admin_set_mandatory_channels")
async def admin_set_mandatory_channels_prompt(callback: CallbackQuery, state: FSMContext):
    if callback.from_user.id not in config.admin_ids:
        return
        
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ انصراف", callback_data="admin_bot_settings")
    
    await callback.message.edit_text(
        "📢 <b>تنظیم کانال‌های عضویت اجباری</b>\n\n"
        "لطفاً آیدی و لینک کانال‌ها را با فرمت زیر ارسال کنید:\n"
        "<code>آیدی کانال | لینک کانال</code>\n\n"
        "در هر خط یک کانال را بنویسید. به عنوان مثال:\n"
        "<code>-100123456789 | https://t.me/mychannel</code>\n"
        "<code>@mychannel2 | https://t.me/mychannel2</code>\n\n"
        "برای <b>غیرفعال کردن</b> عضویت اجباری، کلمه <code>none</code> را ارسال کنید.",
        reply_markup=builder.as_markup()
    )
    await state.set_state(AdminState.waiting_for_mandatory_channels)
    await callback.answer()

@router.message(AdminState.waiting_for_mandatory_channels)
async def process_set_mandatory_channels(message: Message, state: FSMContext):
    if message.from_user.id not in config.admin_ids:
        return
    val = message.text.strip()
    
    if val.lower() == "none":
        ids_str, links_str = "", ""
    else:
        ids, links = [], []
        for line in val.split('\n'):
            if '|' in line:
                i, l = line.split('|', 1)
                ids.append(i.strip())
                links.append(l.strip())
        ids_str = ",".join(ids)
        links_str = ",".join(links)
        
    async with AsyncSessionLocal() as session:
        await set_setting(session, "mandatory_join_ids", ids_str)
        await set_setting(session, "mandatory_join_links", links_str)
        
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت به تنظیمات", callback_data="admin_bot_settings")
    await message.answer(
        f"✅ تنظیمات عضویت اجباری با موفقیت ذخیره شد.\n\nآیدی‌ها: <code>{ids_str or 'غیرفعال'}</code>\nلینک‌ها: <code>{links_str or 'غیرفعال'}</code>", 
        reply_markup=builder.as_markup()
    )
    await state.clear()


@router.callback_query(F.data == 'admin_set_midasbuy_api')
async def ask_midasbuy_api(callback: CallbackQuery, state: FSMContext):
    builder = InlineKeyboardBuilder()
    builder.button(text='❌ لغو', callback_data='admin_bot_settings')
    await callback.message.edit_text('⚙️ <b>تنظیم کلید API رسمی Midasbuy</b>\n\nلطفاً کلید API خود را ارسال کنید:', reply_markup=builder.as_markup())
    await state.set_state(AdminState.waiting_for_midasbuy_setting)
    await callback.answer()

@router.message(AdminState.waiting_for_midasbuy_setting)
async def process_set_midasbuy_api(message: Message, state: FSMContext):
    if message.from_user.id not in config.admin_ids:
        return
    val = message.text.strip()
    async with AsyncSessionLocal() as session:
        await set_setting(session, 'midasbuy_api_key', val)
    builder = InlineKeyboardBuilder()
    builder.button(text='🔙 بازگشت به تنظیمات', callback_data='admin_bot_settings')
    await message.answer('✅ کلید API با موفقیت ذخیره شد.', reply_markup=builder.as_markup())
    await state.clear()

@router.callback_query(F.data.startswith("admin_send_msg_"))
async def prompt_user_message(callback: CallbackQuery, state: FSMContext):
    user_id = int(callback.data.split("_")[3])
    await state.update_data(msg_target_user_id=user_id)
    await state.set_state(AdminState.waiting_for_user_message)
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت", callback_data="admin_manage_user")
    await callback.message.edit_text(
        "✉️ لطفاً پیام خود را برای این کاربر بفرستید:",
        reply_markup=builder.as_markup()
    )

@router.message(AdminState.waiting_for_user_message)
async def process_user_message(message: Message, state: FSMContext):
    data = await state.get_data()
    target_user_id = data.get("msg_target_user_id")
    if not target_user_id:
        return await admin_dashboard(message)
    
    try:
        await message.bot.send_message(
            chat_id=target_user_id,
            text=f"✉️ <b>پیام از طرف پشتیبانی:</b>\n\n{message.text}"
        )
        await message.answer("✅ پیام شما با موفقیت به کاربر ارسال شد.")
    except Exception as e:
        await message.answer(f"❌ خطا در ارسال پیام به کاربر: {e}")
        
    await state.clear()
    await send_user_details(message, target_user_id)

@router.callback_query(F.data == "admin_set_usdt_rate")
async def ask_usdt_rate(callback: CallbackQuery, state: FSMContext):
    await state.set_state(AdminState.waiting_for_usdt_rate)
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت", callback_data="admin_bot_settings")
    await callback.message.edit_text(
        "💵 لطفاً نرخ روز تتر را به تومان وارد کنید (مثلا 60000):",
        reply_markup=builder.as_markup()
    )

@router.message(AdminState.waiting_for_usdt_rate)
async def process_usdt_rate(message: Message, state: FSMContext):
    if not message.text.isdigit():
        return await message.answer("⚠️ لطفاً فقط عدد وارد کنید:")
    
    rate = int(message.text)
    if rate < 1000:
        return await message.answer("⚠️ مبلغ نامعتبر است.")
        
    async with AsyncSessionLocal() as session:
        await set_setting(session, "usdt_rate", str(rate))
        
    await message.answer(f"✅ نرخ تتر با موفقیت به {rate:,.0f} تومان تنظیم شد.")
    await state.clear()
    await admin_dashboard(message)

@router.callback_query(F.data == "admin_banned_players")
async def admin_banned_players_menu(callback: CallbackQuery, state: FSMContext = None):
    if state:
        await state.clear()
    if callback.from_user.id not in config.admin_ids:
        return await callback.answer("عدم دسترسی", show_alert=True)
        
    async with AsyncSessionLocal() as session:
        stmt = select(BannedPlayer).order_by(BannedPlayer.created_at.desc())
        banned = (await session.execute(stmt)).scalars().all()
        
    builder = InlineKeyboardBuilder()
    builder.button(text="➕ مسدود کردن آیدی جدید", callback_data="ban_player_prompt")
    builder.button(text="➖ رفع مسدودیت آیدی", callback_data="unban_player_prompt")
    builder.button(text="🔙 بازگشت به داشبورد", callback_data="admin_dashboard_back")
    builder.adjust(1)
    
    if not banned:
        text = "🚫 <b>لیست آیدی‌های بازی مسدود شده</b>\n\nهنوز هیچ آیدی بازی مسدود نشده است."
    else:
        text = "🚫 <b>لیست آیدی‌های بازی مسدود شده (تعداد: {}):</b>\n\n".format(len(banned))
        for i, bp in enumerate(banned, 1):
            text += f"{i}. <code>{bp.player_id}</code> (مسدود شده در {bp.created_at.strftime('%Y-%m-%d %H:%M')})\n"
            
    await callback.message.edit_text(text, reply_markup=builder.as_markup())
    await callback.answer()

@router.callback_query(F.data == "ban_player_prompt")
async def ban_player_prompt(callback: CallbackQuery, state: FSMContext):
    if callback.from_user.id not in config.admin_ids:
        return
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ انصراف", callback_data="admin_banned_players")
    await callback.message.edit_text("لطفاً آیدی بازی (Player ID) مورد نظر جهت مسدودسازی را ارسال کنید:", reply_markup=builder.as_markup())
    await state.set_state(AdminState.waiting_for_ban_player_id)
    await callback.answer()

@router.message(AdminState.waiting_for_ban_player_id)
async def process_ban_player_id(message: Message, state: FSMContext):
    if message.from_user.id not in config.admin_ids:
        return
    player_id = message.text.strip()
    if not player_id:
        return await message.answer("⚠️ لطفاً یک آیدی معتبر وارد کنید:")
        
    async with AsyncSessionLocal() as session:
        stmt = select(BannedPlayer).where(BannedPlayer.player_id == player_id)
        existing = (await session.execute(stmt)).scalar_one_or_none()
        if existing:
            await message.answer(f"⚠️ آیدی بازی <code>{player_id}</code> قبلاً مسدود شده است.")
        else:
            new_ban = BannedPlayer(player_id=player_id)
            session.add(new_ban)
            await session.commit()
            await message.answer(f"✅ آیدی بازی <code>{player_id}</code> با موفقیت مسدود شد.")
            
    await state.clear()
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت به لیست آیدی‌ها", callback_data="admin_banned_players")
    await message.answer("برای بازگشت به منوی آیدی‌های مسدود دکمه زیر را بزنید:", reply_markup=builder.as_markup())

@router.callback_query(F.data == "unban_player_prompt")
async def unban_player_prompt(callback: CallbackQuery, state: FSMContext):
    if callback.from_user.id not in config.admin_ids:
        return
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ انصراف", callback_data="admin_banned_players")
    await callback.message.edit_text("لطفاً آیدی بازی (Player ID) مورد نظر جهت رفع مسدودیت را ارسال کنید:", reply_markup=builder.as_markup())
    await state.set_state(AdminState.waiting_for_unban_player_id)
    await callback.answer()

@router.message(AdminState.waiting_for_unban_player_id)
async def process_unban_player_id(message: Message, state: FSMContext):
    if message.from_user.id not in config.admin_ids:
        return
    player_id = message.text.strip()
    if not player_id:
        return await message.answer("⚠️ لطفاً یک آیدی معتبر وارد کنید:")
        
    async with AsyncSessionLocal() as session:
        stmt = select(BannedPlayer).where(BannedPlayer.player_id == player_id)
        existing = (await session.execute(stmt)).scalar_one_or_none()
        if not existing:
            await message.answer(f"⚠️ آیدی بازی <code>{player_id}</code> در لیست آیدی‌های مسدود یافت نشد.")
        else:
            await session.delete(existing)
            await session.commit()
            await message.answer(f"✅ آیدی بازی <code>{player_id}</code> با موفقیت رفع مسدودیت شد.")
            
    await state.clear()
    builder = InlineKeyboardBuilder()
    builder.button(text="🔙 بازگشت به لیست آیدی‌ها", callback_data="admin_banned_players")
    await message.answer("برای بازگشت به منوی آیدی‌های مسدود دکمه زیر را بزنید:", reply_markup=builder.as_markup())