from aiogram import Router, F
from aiogram.types import CallbackQuery, Message, InlineKeyboardButton
from aiogram.utils.keyboard import InlineKeyboardBuilder
from aiogram.fsm.context import FSMContext
from aiogram.fsm.state import State, StatesGroup
from sqlalchemy import select, func
import aiohttp

from database.database import AsyncSessionLocal
from database.product_crud import get_all_categories, get_products_by_category, get_product_by_id, get_and_consume_gift_card, get_parent_categories, get_subcategories
from database.crud import get_user_by_telegram_id, get_setting, get_group_id
from database.models import Order, User, Category, Product, GiftCard
from core.config import config
import json
from core.emojis import p_em
from services.midasbuy_service import record_midasbuy_event


router = Router()

PUBG_BASE_REDEEM_UC = [8100, 3850, 1800, 660, 325, 60]
SUSPECTED_BAD_GIFT_CARDS = set()

class ShopState(StatesGroup):
    waiting_for_player_id = State()
    waiting_for_cod_email = State()

class ShopState(StatesGroup):
    waiting_for_player_id = State()
    waiting_for_cod_email = State()
    waiting_for_cod_password = State()
    waiting_for_cod_id = State()
    waiting_for_receipt_upload = State()
    waiting_for_manual_email = State()
    waiting_for_manual_password = State()

async def fetch_pubg_player_name(player_id: str) -> str | None:
    async with AsyncSessionLocal() as session:
        api_key = await get_setting(session, "midasbuy_api_key", config.midasbuy_api_key)
    
    url = "https://giftclupbot.ir/partner/api.php"
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    data = {
        "action": "get_name",
        "playerId": str(player_id).strip()
    }
    try:
        async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(ssl=False)) as session:
            async with session.post(url, headers=headers, json=data, timeout=10) as response:
                text = await response.text()
                try:
                    import json
                    res_json = json.loads(text)
                except Exception:
                    res_json = {}
                
                # Check success first
                if res_json.get("status") == "success" and "data" in res_json:
                    return res_json["data"].get("player_name")
                
                # Check if it's explicitly CHARACTER_NOT_FOUND or invalid player (status 400 or status: error)
                if res_json.get("status") == "error" or res_json.get("error_code") == "CHARACTER_NOT_FOUND" or response.status == 400:
                    return None
                    
                # If it's 401, 403, or 429, we proceed with fallback to not block purchases when API key has issues
                if response.status in [401, 403, 429]:
                    try:
                        print(f"API key issue or rate limit: status={response.status}, response={text}")
                    except Exception:
                        pass
                    return f"کاربر پابجی ({player_id})"
    except Exception as e:
        try:
            print(f"Error fetching player name: {e}")
        except Exception:
            pass
        
    return f"کاربر پابجی ({player_id})"

async def activate_pubg_code(player_id: str, uc_code: str) -> dict:
    async with AsyncSessionLocal() as session:
        api_key = await get_setting(session, "midasbuy_api_key", config.midasbuy_api_key)
        
    url = "https://giftclupbot.ir/partner/api.php"
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    data = {
        "action": "redeem",
        "playerId": str(player_id).strip(),
        "voucherCode": str(uc_code).strip()
    }
    try:
        async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(ssl=False)) as session:
            async with session.post(url, headers=headers, json=data, timeout=20) as response:
                if response.status == 200:
                    res_json = await response.json()
                    if res_json.get("status") == "success":
                        inner_data = res_json.get("data", {})
                        return {
                            "success": True,
                            "data": {
                                "status": "success",
                                "transaction_id": inner_data.get("transaction_id"),
                                "player_name": inner_data.get("player_name"),
                                "amount": inner_data.get("amount")
                            }
                        }
                    else:
                        err_msg = res_json.get("message") or res_json.get("error") or "خطا در وب‌سرویس گیفت کلاب"
                        return {
                            "success": False,
                            "message": err_msg,
                            "data": {
                                "status": "failed",
                                "message": err_msg
                            }
                        }
                else:
                    # Map error codes to standard messages that trigger correct release/retry logic in the caller
                    if response.status == 429:
                        err_msg = "limit reached: عبور از سقف مجاز ریکوئست روزانه/ماهانه"
                    elif response.status == 403:
                        err_msg = "limit/expired: نداشتن پلن فعال یا انقضای اشتراک"
                    elif response.status == 402:
                        err_msg = "limit/insufficient: موجودی ناکافی در حساب"
                    else:
                        try:
                            res_json = await response.json()
                            err_msg = res_json.get("message") or f"HTTP Error {response.status}"
                        except Exception:
                            err_msg = f"HTTP Error {response.status}"
                    return {
                        "success": False,
                        "message": err_msg,
                        "data": {
                            "status": "failed",
                            "message": err_msg
                        }
                    }
    except Exception as e:
        return {
            "success": False,
            "message": str(e),
            "data": {
                "status": "failed",
                "message": str(e)
            }
        }

async def check_pubg_code_status(uc_code: str) -> dict | None:
    # The new GiftClub API does not support check_code action.
    # Return None so the caller skips/ignores the fallback verification.
    return None

def parse_pubg_uc_amount(product_name: str) -> str | None:
    import re
    match = re.search(r"(\d+)\s*(?:uc|یوسی)", product_name, re.IGNORECASE)
    val = None
    if match:
        val = match.group(1)
    else:
        match = re.search(r"(?:uc|یوسی)\s*(\d+)", product_name, re.IGNORECASE)
        if match:
            val = match.group(1)
            
    if val:
        # Normalize Persian/Arabic digits to English digits
        persian_digits = "۰۱۲۳۴۵۶۷۸۹"
        arabic_digits = "٠١٢٣٤٥٦٧٨٩"
        for i in range(10):
            val = val.replace(persian_digits[i], str(i)).replace(arabic_digits[i], str(i))
        return val
    return None

def build_pubg_redeem_composition(total_uc: str | int | None) -> list[tuple[str, int]]:
    try:
        remaining = int(total_uc)
    except (TypeError, ValueError):
        return []

    if remaining <= 0:
        return []

    counts: dict[int, int] = {}
    for value in PUBG_BASE_REDEEM_UC:
        count, remaining = divmod(remaining, value)
        if count:
            counts[value] = count

    if remaining != 0:
        return []

    return [(str(value), count) for value, count in counts.items()]

async def consume_pubg_component_code(session, uc_type: str, user_id: int) -> tuple[str | None, GiftCard | None]:
    import logging
    logger = logging.getLogger("bot.shop_flow")
    logger.info(f"🔍 consume_pubg_component_code: Searching for unsold code for UC type '{uc_type}' for user {user_id}")
    
    # 1. Fetch all unsold gift cards (excluding suspected bad ones)
    stmt = select(GiftCard).where(GiftCard.is_sold == False)
    if SUSPECTED_BAD_GIFT_CARDS:
        stmt = stmt.where(~GiftCard.id.in_(list(SUSPECTED_BAD_GIFT_CARDS)))
    stmt = stmt.order_by(GiftCard.id.asc())
    
    result = await session.execute(stmt)
    gift_cards = result.scalars().all()
    
    logger.info(f"🔍 Found {len(gift_cards)} total unsold gift cards in database.")
    
    # 2. Iterate and match product name UC amount
    for gc in gift_cards:
        prod = await session.get(Product, gc.product_id)
        if not prod:
            logger.warning(f"⚠️ Gift card ID {gc.id} references non-existent Product ID {gc.product_id}")
            continue
            
        parsed_uc = parse_pubg_uc_amount(prod.name)
        logger.info(f"   - Checking GC ID {gc.id} | Product '{prod.name}' (ID: {prod.id}) | Parsed UC: '{parsed_uc}' vs Target: '{uc_type}'")
        
        if parsed_uc == str(uc_type):
            gc.is_sold = True
            gc.sold_to_user_id = user_id
            await session.flush()
            logger.info(f"✅ Found match! GC ID {gc.id} (Code: {gc.code}) assigned to user {user_id}")
            return gc.code, gc
            
    logger.error(f"❌ No matching unsold code found for UC type '{uc_type}'!")
    return None, None

async def release_pubg_component_code(session, gift_card: GiftCard | None) -> None:
    if gift_card:
        gift_card.is_sold = False
        gift_card.sold_to_user_id = None
        await session.flush()

async def process_pubg_component_code(session, player_id: str, code: str, gift_card: GiftCard, uc_type: str) -> tuple[str, str]:
    res = await activate_pubg_code(player_id, code)
    inner_data = res.get("data", {}) if isinstance(res, dict) else {}
    api_success = isinstance(res, dict) and res.get("success") is True
    deposit_status = inner_data.get("status") == "success"
    error_msg = inner_data.get("message") or (res.get("message") if isinstance(res, dict) else None) or "خطای فعال‌سازی"

    if api_success and deposit_status:
        return "success", f"✅ {uc_type} UC: <code>{code}</code>"

    status_data = await check_pubg_code_status(code)
    if status_data and status_data.get("status") == "activated":
        if str(status_data.get("activated_to")) == str(player_id):
            return "success", f"✅ {uc_type} UC: <code>{code}</code> (Verified)"
        return "used", f"⚠️ کد {uc_type} UC قبلا برای پلیر دیگری استفاده شده: <code>{code}</code>"

    lower_error = error_msg.lower()
    if any(key in lower_error for key in ["player not found", "invalid game id", "limit", "quota", "maximum", "timeout", "network", "transaction failed", "refunded"]):
        await release_pubg_component_code(session, gift_card)
        if gift_card:
            SUSPECTED_BAD_GIFT_CARDS.add(gift_card.id)
        return "returned", f"⚠️ کد {uc_type} UC برگشت خورد: {error_msg}"
    if any(key in lower_error for key in ["already", "used", "redeemed"]):
        return "used", f"⚠️ کد {uc_type} UC قبلا استفاده شده: <code>{code}</code>"
    if any(key in lower_error for key in ["invalid code", "code not found"]):
        return "invalid_code", f"❌ کد {uc_type} UC نامعتبر است"

    await release_pubg_component_code(session, gift_card)
    if gift_card:
        SUSPECTED_BAD_GIFT_CARDS.add(gift_card.id)
    return "error", f"⚠️ خطای فعال‌سازی {uc_type} UC: {error_msg}"


def get_product_type(category_name: str, product_name: str) -> str:
    cat_lower = category_name.lower()
    prod_lower = product_name.lower()
    if any(k in cat_lower or k in prod_lower for k in ["ردیم", "گیفت", "gift", "code", "card", "کارت"]):
        return "redeem"
    elif any(k in cat_lower or k in prod_lower for k in ["کالاف", "کال اف", "کال آف", "cod", "cp", "سی پی", "سی‌پی", "call of"]):
        return "cod"
    elif any(k in cat_lower or k in prod_lower for k in ["پابجی", "pubg", "uc", "یوسی"]):
        return "pubg"
    else:
        return "manual"

async def show_join_required_message(callback: CallbackQuery, unjoined_links: list[str]):
    builder = InlineKeyboardBuilder()
    
    for i, link in enumerate(unjoined_links, 1):
        btn_text = f"📢 عضویت در کانال/گروه {i}"
        if "t.me" in link or "http" in link:
            builder.button(text=btn_text, url=link)
        else:
            builder.button(text=f"📢 کانال/گروه {link}", url=f"https://t.me/{link.replace('@', '')}")
            
    builder.button(text="🔄 بررسی مجدد عضویت", callback_data="check_membership")
    builder.button(text="🔙 بازگشت به منوی اصلی", callback_data="back_to_main")
    builder.adjust(1)
    
    text = p_em(
        "⚠️ <b>عضویت اجباری الزامی است!</b>\n\n"
        "برای خرید محصولات و دسترسی به فروشگاه، لطفاً ابتدا در کانال(ها) یا گروه(های) زیر عضو شوید:\n\n"
        "👇 پس از عضویت، روی دکمه <b>بررسی مجدد عضویت</b> بزنید:"
    )
    
    await callback.message.edit_text(text, reply_markup=builder.as_markup())

@router.callback_query(F.data == "check_membership")
async def process_check_membership(callback: CallbackQuery):
    from core.utils import check_user_membership
    async with AsyncSessionLocal() as session:
        is_member, unjoined_links = await check_user_membership(callback.bot, callback.from_user.id, session)
        if is_member:
            await callback.answer("✅ با تشکر! عضویت شما تایید شد. وارد فروشگاه می‌شوید...", show_alert=True)
            return await show_categories(callback)
        else:
            await callback.answer("❌ شما هنوز عضو تمام کانال‌ها/گروه‌ها نشده‌اید.", show_alert=True)
            return await show_join_required_message(callback, unjoined_links)

@router.callback_query(F.data.startswith("shop_menu"))
async def show_categories(callback: CallbackQuery):
    from core.utils import check_user_membership
    async with AsyncSessionLocal() as session:
        is_member, unjoined_links = await check_user_membership(callback.bot, callback.from_user.id, session)
        if not is_member:
            return await show_join_required_message(callback, unjoined_links)

    parts = callback.data.split("_")
    page = int(parts[2]) if len(parts) > 2 else 1
    per_page = 10
    
    async with AsyncSessionLocal() as session:
        categories = await get_parent_categories(session)

    if not categories:
        builder = InlineKeyboardBuilder()
        builder.button(text="🔙 بازگشت", callback_data="back_to_main", style="danger")
        await callback.message.edit_text(
            p_em("🛍 <b>بخش فروشگاه</b>\n\nهنوز هیچ محصولی در فروشگاه ثبت نشده است. لطفاً ابتدا از پنل مدیریت فایل محصولات را وارد کنید."),
            reply_markup=builder.as_markup()
        )
        await callback.answer()
        return
        
    total_pages = max(1, (len(categories) + per_page - 1) // per_page)
    start = (page - 1) * per_page
    end = start + per_page
    current_cats = categories[start:end]
        
    builder = InlineKeyboardBuilder()
    for cat in current_cats:
        builder.button(text=f"📂 {cat.name}", callback_data=f"cat_{cat.id}_1", style="primary")
        
    nav_buttons = []
    if page > 1:
        nav_buttons.append(InlineKeyboardButton(text="⬅️ قبلی", callback_data=f"shop_menu_{page-1}", style="primary"))
    if page < total_pages:
        nav_buttons.append(InlineKeyboardButton(text="صفحه بعد ⬅️", callback_data=f"shop_menu_{page+1}"))
        
    builder.adjust(2)
    if nav_buttons:
        builder.row(*nav_buttons)
        
    builder.row(InlineKeyboardButton(text="🔙 بازگشت به منوی اصلی", callback_data="back_to_main"))
    
    await callback.message.edit_text(
        p_em(f"🛍 <b>بخش فروشگاه</b> (صفحه {page})\n\nلطفاً یک دسته‌بندی را انتخاب کنید:"),
        reply_markup=builder.as_markup()
    )
    await callback.answer()

@router.callback_query(F.data.startswith("cat_"))
async def show_products(callback: CallbackQuery):
    parts = callback.data.split("_")
    cat_id = int(parts[1])
    page = int(parts[2]) if len(parts) > 2 else 1
    per_page = 10
    
    async with AsyncSessionLocal() as session:
        category = await session.get(Category, cat_id)
        if not category:
            return await callback.answer("دسته‌بندی یافت نشد!", show_alert=True)
            
        subcategories = await get_subcategories(session, cat_id)
        
        if subcategories:
            total_pages = max(1, (len(subcategories) + per_page - 1) // per_page)
            start = (page - 1) * per_page
            end = start + per_page
            current_subcats = subcategories[start:end]
            
            builder = InlineKeyboardBuilder()
            for subcat in current_subcats:
                builder.button(text=f"📁 {subcat.name}", callback_data=f"cat_{subcat.id}_1", style="primary")
                
            nav_buttons = []
            if page > 1:
                nav_buttons.append(InlineKeyboardButton(text="⬅️ قبلی", callback_data=f"cat_{cat_id}_{page-1}", style="primary"))
            if page < total_pages:
                nav_buttons.append(InlineKeyboardButton(text="بعدی ➡️", callback_data=f"cat_{cat_id}_{page+1}", style="primary"))
                
            builder.adjust(2)
            if nav_buttons:
                builder.row(*nav_buttons)
                
            builder.row(InlineKeyboardButton(text="🔙 بازگشت به دسته‌بندی‌ها", callback_data="shop_menu_1", style="danger"))
            
            await callback.message.edit_text(
                p_em(f"📂 <b>زیرمجموعه‌های {category.name}</b> (صفحه {page})\n\nلطفاً یک بخش را انتخاب کنید:"),
                reply_markup=builder.as_markup()
            )
        else:
            products = await get_products_by_category(session, cat_id)
            if not products:
                return await callback.answer("محصولی در این دسته وجود ندارد.", show_alert=True)
                
            total_pages = max(1, (len(products) + per_page - 1) // per_page)
            start = (page - 1) * per_page
            end = start + per_page
            current_prods = products[start:end]
            
            builder = InlineKeyboardBuilder()
            for prod in current_prods:
                builder.button(text=f"🛒 {prod.name} - {prod.price:,.0f}T", callback_data=f"prod_{prod.id}_{page}", style="primary")
                
            nav_buttons = []
            if page > 1:
                nav_buttons.append(InlineKeyboardButton(text="⬅️ قبلی", callback_data=f"cat_{cat_id}_{page-1}", style="primary"))
            if page < total_pages:
                nav_buttons.append(InlineKeyboardButton(text="بعدی ➡️", callback_data=f"cat_{cat_id}_{page+1}", style="primary"))
                
            builder.adjust(1)
            if nav_buttons:
                builder.row(*nav_buttons)
                
            if category.parent_id:
                back_callback = f"cat_{category.parent_id}_1"
                back_text = "🔙 بازگشت به زیرمجموعه‌ها"
            else:
                back_callback = "shop_menu_1"
                back_text = "🔙 بازگشت به دسته‌بندی‌ها"
                
            builder.row(InlineKeyboardButton(text=back_text, callback_data=back_callback, style="danger"))
            
            await callback.message.edit_text(
                p_em(f"📦 <b>لیست محصولات {category.name}</b> (صفحه {page})\n\nمحصول مورد نظر خود را انتخاب کنید:"),
                reply_markup=builder.as_markup()
            )

@router.callback_query(F.data.startswith("prod_"))
async def product_details(callback: CallbackQuery):
    parts = callback.data.split("_")
    prod_id = int(parts[1])
    back_page = parts[2] if len(parts) > 2 else 1
    qty = int(parts[3]) if len(parts) > 3 else 1
    
    async with AsyncSessionLocal() as session:
        prod = await get_product_by_id(session, prod_id)
        
    if not prod:
        return await callback.answer("محصول یافت نشد!", show_alert=True)
        
    builder = InlineKeyboardBuilder()
    
    # Quantity row
    builder.row(
        InlineKeyboardButton(text="➖", callback_data=f"prod_{prod.id}_{back_page}_{max(1, qty-1)}", style="primary"),
        InlineKeyboardButton(text=f"{qty} عدد", callback_data="ignore"),
        InlineKeyboardButton(text="➕", callback_data=f"prod_{prod.id}_{back_page}_{qty+1}", style="primary")
    )
    
    total_price = prod.price * qty
    builder.row(InlineKeyboardButton(text=f"✅ خرید ({total_price:,.0f}T)", callback_data=f"buy_{prod.id}_{qty}", style="success"))
    builder.row(InlineKeyboardButton(text="🔙 بازگشت", callback_data=f"cat_{prod.category_id}_{back_page}", style="danger"))
    
    stock_text = "نامحدود" if prod.stock == -1 else str(prod.stock)
    
    await callback.message.edit_text(
        p_em(f"💎 <b>{prod.name}</b>\n\n"
        f"📝 <b>توضیحات:</b> {prod.description or 'ندارد'}\n"
        f"💵 <b>قیمت واحد:</b> {prod.price:,.0f} تومان\n"
        f"📦 <b>موجودی:</b> {stock_text}\n\n"
        f"آیا مایل به خرید {qty} عدد از این محصول هستید؟"),
        reply_markup=builder.as_markup()
    )

async def send_payment_options(message_or_callback, state: FSMContext, user: User, prod: Product, qty: int, details: dict = None):
    """
    نمایش صفحه انتخاب روش پرداخت
    """
    total_price = prod.price * qty
    details_str = json.dumps(details) if details else "{}"
    
    # ذخیره در FSM برای استفاده موقت
    await state.update_data(
        checkout_prod_id=prod.id,
        checkout_qty=qty,
        checkout_amount=total_price,
        checkout_details=details_str
    )
    
    builder = InlineKeyboardBuilder()
    
    # پرداخت از کیف پول در صورت کفایت موجودی
    if user.wallet_balance >= total_price:
        builder.button(text=f"💰 پرداخت از کیف پول ({user.wallet_balance:,.0f} تومان)", callback_data="pay_opt_wallet")

    async with AsyncSessionLocal() as session:
        zibal_enabled = await get_setting(session, "zibal_enabled", "true")
        nowpayments_enabled = await get_setting(session, "nowpayments_enabled", "true")

    if zibal_enabled == "true":
        builder.button(text="💳 پرداخت آنلاین زیبال", callback_data="pay_opt_zibal")
    builder.button(text="💸 کارت به کارت (آپلود فیش)", callback_data="pay_opt_receipt")
    if nowpayments_enabled == "true":
        builder.button(text="🪙 پرداخت با تتر (USDT)", callback_data="pay_opt_usdt")
    builder.button(text="❌ انصراف", callback_data="back_to_main", style="danger")
    
    builder.adjust(1)
    
    invoice_text = (
        f"🧾 <b>فاکتور نهایی خرید</b>\n"
        f"〰️〰️〰️〰️〰️〰️〰️\n"
        f"📦 <b>محصول:</b> {prod.name}\n"
        f"🔢 <b>تعداد:</b> {qty}\n"
        f"💵 <b>مجموع مبلغ:</b> {total_price:,.0f} تومان\n"
    )
    
    if details:
        invoice_text += "\n⚙️ <b>مشخصات سفارش:</b>\n"
        if "player_id" in details:
            invoice_text += f"- آیدی بازیکن: <code>{details.get('player_id')}</code>\n"
        if "player_name" in details:
            invoice_text += f"- نام بازیکن: {details.get('player_name')}\n"
        if "cod_email" in details:
            invoice_text += f"- اکتیویژن: {details.get('cod_email')}\n"
        if "cod_id" in details:
            invoice_text += f"- آیدی بازی: <code>{details.get('cod_id')}</code>\n"
        if "manual_email" in details:
            invoice_text += f"- ایمیل: {details.get('manual_email')}\n"
            
    invoice_text += "\n👇 لطفا روش پرداخت خود را انتخاب کنید:"
    
    if isinstance(message_or_callback, CallbackQuery):
        await message_or_callback.message.edit_text(p_em(invoice_text), reply_markup=builder.as_markup())
    else:
        await message_or_callback.answer(p_em(invoice_text), reply_markup=builder.as_markup())

async def fulfill_order(session, bot, order: Order, user: User, prod: Product):
    # بررسی دسته‌بندی محصول برای تشخیص فلو
    category = await session.get(Category, prod.category_id)
    parent_category = None
    if category and category.parent_id:
        parent_category = await session.get(Category, category.parent_id)
    cat_full_name = category.name if category else ""
    if parent_category:
        cat_full_name += " " + parent_category.name
        
    prod_type = get_product_type(cat_full_name, prod.name)
    
    qty = order.quantity
    total_price = order.amount
    details = json.loads(order.details) if order.details else {}
    
    if prod_type == "redeem":
        # سفارش‌های مستقیم گیفت کارت/کد ردیم
        gift_codes = []
        for _ in range(qty):
            gc = await get_and_consume_gift_card(session, prod.id, user.id)
            if gc:
                gift_codes.append(gc)
            else:
                break
                
        if len(gift_codes) == qty:
            order.status = "completed"
            record_midasbuy_event(order, "finished", {"source": "bot_auto_delivery", "order_id": order.id})
            if prod.stock > 0:
                prod.stock -= qty
            await session.commit()
            
            codes_str = "\n".join([f"<code>{c}</code>" for c in gift_codes])
            try:
                await bot.send_message(
                    chat_id=user.telegram_id,
                    text=p_em(f"✅ <b>سفارش #{order.id} با موفقیت تحویل شد!</b>\n\n"
                         f"💎 محصول: {prod.name}\n"
                         f"تعداد: {qty}\n"
                         f"🎁 <b>کد(های) شما:</b>\n{codes_str}\n\n"
                         f"مبلغ {total_price:,.0f} تومان پرداخت شد.")
                )
            except Exception:
                pass
            return
            
    # سفارش پابجی
    if prod_type == "pubg":
        player_id = details.get("player_id")
        player_name = details.get("player_name")
        product_uc = parse_pubg_uc_amount(prod.name)
        composition = build_pubg_redeem_composition(product_uc)

        if composition:
            success_lines = []
            failed_lines = []
            count = 1

            for _ in range(qty):
                for uc_type, component_count in composition:
                    for _ in range(component_count):
                        code, gift_card = await consume_pubg_component_code(session, uc_type, user.id)
                        if not code or not gift_card:
                            failed_lines.append(f"{count}. ⚠️ کد {uc_type} UC موجود نیست")
                            count += 1
                            continue

                        status, log_line = await process_pubg_component_code(session, player_id, code, gift_card, uc_type)
                        if status == "success":
                            success_lines.append(f"{count}. {log_line}")
                        else:
                            failed_lines.append(f"{count}. {log_line}")
                        count += 1

            if not failed_lines:
                order.status = "completed"
                record_midasbuy_event(order, "finished", {
                    "source": "midasbuy_code_activation",
                    "order_id": order.id,
                    "composition": composition,
                })
                if prod.stock > 0:
                    prod.stock -= qty
                await session.commit()

                codes_str = "\n".join(success_lines)
                try:
                    await bot.send_message(
                        chat_id=user.telegram_id,
                        text=p_em(f"✅ <b>سفارش #{order.id} با موفقیت به صورت خودکار شارژ شد!</b>\n\n"
                             f"🎮 نام بازیکن: {player_name}\n"
                             f"🆔 آیدی عددی: <code>{player_id}</code>\n"
                             f"📦 محصول: {prod.name}\n"
                             f"🔢 تعداد: {qty}\n\n"
                             f"🎁 <b>جزئیات شارژ:</b>\n{codes_str}")
                    )
                except Exception:
                    pass

                admin_text = (
                    f"🏷 Processing order {order.id}\n\n"
                    f"👤 Customer: {user.full_name} (@{user.username or 'NoUsername'})\n"
                    f"🆔 Telegram ID: <code>{user.telegram_id}</code>\n"
                    f"🎮 Player: {player_name}\n"
                    f"🆔 ID: {player_id}\n"
                    f"📦 Product: {prod.name}\n"
                    f"🔢 Amount: {qty}\n\n"
                    f"---- Detail of Process ----\n\n"
                    + "\n".join(success_lines)
                )
                group_id = await get_group_id(session, "orders", config.fulfillment_group_id)
                try:
                    await bot.send_message(chat_id=group_id, text=p_em(admin_text))
                except Exception:
                    pass
                return

            order.status = "pending"
            record_midasbuy_event(order, "paid_pending_delivery", {
                "source": "midasbuy_code_activation",
                "order_id": order.id,
                "composition": composition,
                "failed": failed_lines,
            })
            if prod.stock > 0:
                prod.stock -= qty
            await session.commit()

            try:
                await bot.send_message(
                    chat_id=user.telegram_id,
                    text=p_em(f"⚠️ <b>سفارش #{order.id} ثبت شد</b>\n\n"
                         f"بخشی از شارژ خودکار انجام نشد و سفارش برای بررسی و واریز دستی به پشتیبانی ارسال شد.")
                )
            except Exception:
                pass

            orders_count = await session.scalar(select(func.count(Order.id)).where(Order.user_id == user.id)) or 0
            admin_text = (
                f"⚠️ <b>خطا در شارژ خودکار یوسی؛ نیاز به بررسی دستی</b>\n\n"
                f"شماره سفارش: {order.id}\n"
                f"کاربر: {user.full_name} (@{user.username or 'بدون نام کاربری'})\n"
                f"آیدی کاربر: <code>{user.telegram_id}</code>\n"
                f"احراز هویت: {'1' if user.is_verified else '0'}\n"
                f"--------------------\n"
                f"محصول: {prod.name}\n"
                f"تعداد: {qty}\n"
                f"- آیدی عددی: {player_id}\n"
                f"- آیدی اسمی: {player_name}\n"
                f"--------------------\n\n"
                f"جزئیات موفق:\n{chr(10).join(success_lines) or 'ندارد'}\n\n"
                f"خطاها:\n{chr(10).join(failed_lines)}\n\n"
                f"مجموع مبلغ سفارش: تومان{total_price:,.0f}\n"
                f"تعداد سفارش های مشتری: {orders_count}"
            )
            builder = InlineKeyboardBuilder()
            builder.button(text="✅ انجام شد", callback_data=f"order_done_{order.id}_{user.telegram_id}", style="success")
            group_id = await get_group_id(session, "orders", config.fulfillment_group_id)
            try:
                await bot.send_message(chat_id=group_id, text=p_em(admin_text), reply_markup=builder.as_markup())
            except Exception:
                pass
            return
        
        # تلاش برای واریز خودکار
        gift_cards = []
        for _ in range(qty):
            gc = await get_and_consume_gift_card(session, prod.id, user.id)
            if gc:
                gift_cards.append(gc)
            else:
                break
                
        if len(gift_cards) == qty:
            success_activations = []
            failed_activations = []
            
            for code in gift_cards:
                res = await activate_pubg_code(player_id, code)
                if res.get("success") and res.get("data", {}).get("status") == "success":
                    success_activations.append(code)
                else:
                    err_msg = res.get("data", {}).get("message") or res.get("message") or "خطای فعال‌سازی"
                    failed_activations.append((code, err_msg))
                    
            if not failed_activations:
                # شارژ موفقیت آمیز
                order.status = "completed"
                record_midasbuy_event(order, "finished", {"source": "midasbuy_code_activation", "order_id": order.id})
                if prod.stock > 0:
                    prod.stock -= qty
                await session.commit()
                
                codes_str = "\n".join([f"<code>{c}</code>" for c in success_activations])
                try:
                    await bot.send_message(
                        chat_id=user.telegram_id,
                        text=p_em(f"✅ <b>سفارش #{order.id} با موفقیت به صورت خودکار شارژ شد!</b>\n\n"
                             f"🎮 نام مستعار: {player_name}\n"
                             f"🆔 آیدی عددی: <code>{player_id}</code>\n"
                             f"📦 محصول: {prod.name}\n"
                             f"🔢 تعداد: {qty}\n\n"
                             f"🎁 <b>کد(های) فعال شده:</b>\n{codes_str}")
                    )
                except Exception:
                    pass
                
                admin_text = (
                    f"🏷 Processing order {order.id}\n\n"
                    f"👤 Customer: {user.full_name} (@{user.username or 'NoUsername'})\n"
                    f"🆔 Telegram ID: <code>{user.telegram_id}</code>\n"
                    f"🎮 Player: {player_name}\n"
                    f"🆔 ID: {player_id}\n"
                    f"📦 Product: {prod.name}\n"
                    f"🔢 Amount: {qty}\n\n"
                    f"---- Detail of Proccess ----\n\n" +
                    "\n".join([f"{i}. ✅ {prod.name}: {c}" for i, c in enumerate(success_activations, 1)])
                )
                group_id = await get_group_id(session, "orders", config.fulfillment_group_id)
                try:
                    await bot.send_message(chat_id=group_id, text=p_em(admin_text))
                except Exception:
                    pass
                return
            else:
                # شارژ با خطا (ارسال دستی)
                order.status = "pending"
                record_midasbuy_event(order, "paid_pending_delivery", {"source": "midasbuy_code_activation", "order_id": order.id})
                if prod.stock > 0:
                    prod.stock -= qty
                await session.commit()
                
                try:
                    await bot.send_message(
                        chat_id=user.telegram_id,
                        text=p_em(f"⚠️ <b>سفارش #{order.id} ثبت شد</b>\n\n"
                             f"به دلیل اختلال موقت در سیستم واریز خودکار، سفارش شما برای بررسی و واریز دستی به بخش پشتیبانی ارسال شد.")
                    )
                except Exception:
                    pass
                    
                failed_str = ", ".join([f"{c} ({err})" for c, err in failed_activations])
                orders_count = await session.scalar(select(func.count(Order.id)).where(Order.user_id == user.id)) or 0
                admin_text = (
                    f"⚠️ <b>خطا در شارژ خودکار یوسی (نیاز به واریز دستی):</b> {failed_str}\n\n"
                    f"شماره سفارش: {order.id}\n\n"
                    f"کاربر: {user.full_name} (@{user.username or 'بدون نام کاربری'})\n"
                    f"آیدی کاربر: <code>{user.telegram_id}</code>\n"
                    f"احراز هویت: {'1' if user.is_verified else '0'}\n"
                    f"--------------------\n"
                    f"محصول: {prod.name}\n"
                    f"تعداد: {qty}\n"
                    f"- ایدی عددی: {player_id}\n"
                    f"- ایدی اسمی: {player_name}\n"
                    f"--------------------\n\n"
                    f"مجموع مبلغ سفارش: تومان{total_price:,.0f}\n"
                    f"تعداد سفارش های مشتری: {orders_count}"
                )
                builder = InlineKeyboardBuilder()
                builder.button(text="✅ انجام شد", callback_data=f"order_done_{order.id}_{user.telegram_id}", style="success")
                group_id = await get_group_id(session, "orders", config.fulfillment_group_id)
                try:
                    await bot.send_message(chat_id=group_id, text=p_em(admin_text), reply_markup=builder.as_markup())
                except Exception:
                    pass
                return
                
    # سفارش دستی (کالاف دیوتی یا سایر موارد)
    order.status = "pending"
    record_midasbuy_event(order, "paid_pending_delivery", {"source": "manual_delivery", "order_id": order.id})
    if prod.stock > 0:
        prod.stock -= qty
    await session.commit()
    
    try:
        await bot.send_message(
            chat_id=user.telegram_id,
            text=p_em(f"✅ <b>سفارش #{order.id} با موفقیت ثبت شد!</b>\n\n"
                 f"سفارش جهت واریز دستی به بخش پشتیبانی ارسال شد.")
        )
    except Exception:
        pass
        
    orders_count = await session.scalar(select(func.count(Order.id)).where(Order.user_id == user.id)) or 0
    
    if prod_type == "cod":
        cod_email = details.get("cod_email")
        cod_password = details.get("cod_password")
        cod_id = details.get("cod_id")
        admin_text = (
            f"شماره سفارش: {order.id}\n\n"
            f"کاربر: {user.full_name} (@{user.username})\n"
            f"آیدی کاربر: <code>{user.telegram_id}</code>\n"
            f"احراز هویت: {'1' if user.is_verified else '0'}\n"
            f"--------------------\n"
            f"ایمیل اکتیویژن: {cod_email}\n"
            f"رمز اکتیویژن: {cod_password}\n"
            f"آیدی بازی: {cod_id}\n"
            f"--------------------\n\n"
            f"محصول: {prod.name}\n"
            f"تعداد: {qty}\n"
            f"مجموع مبلغ سفارش: تومان{total_price:,.0f}\n"
            f"تعداد سفارش های مشتری: {orders_count}"
        )
    elif prod_type == "manual":
        manual_email = details.get("manual_email")
        manual_password = details.get("manual_password")
        admin_text = (
            f"شماره سفارش: {order.id}\n\n"
            f"کاربر: {user.full_name} (@{user.username})\n"
            f"آیدی کاربر: <code>{user.telegram_id}</code>\n"
            f"احراز هویت: {'1' if user.is_verified else '0'}\n"
            f"--------------------\n"
            f"ایمیل اکانت: {manual_email}\n"
            f"رمز عبور: {manual_password}\n"
            f"--------------------\n\n"
            f"محصول: {prod.name}\n"
            f"تعداد: {qty}\n"
            f"مجموع مبلغ سفارش: تومان{total_price:,.0f}\n"
            f"تعداد سفارش های مشتری: {orders_count}"
        )
    else:
        player_id = details.get("player_id")
        player_name = details.get("player_name")
        info_line = f"- اطلاعات/آیدی: {player_id}\n" if player_id else ""
        name_line = f"- نام بازی: {player_name}\n" if player_name else ""
        admin_text = (
            f"شماره سفارش: {order.id}\n\n"
            f"کاربر: {user.full_name} (@{user.username or 'بدون نام کاربری'})\n"
            f"آیدی کاربر: <code>{user.telegram_id}</code>\n"
            f"احراز هویت: {'1' if user.is_verified else '0'}\n"
            f"--------------------\n"
            f"محصول: {prod.name}\n"
            f"تعداد: {qty}\n"
            f"{info_line}"
            f"{name_line}"
            f"--------------------\n\n"
            f"مجموع مبلغ سفارش: تومان{total_price:,.0f}\n"
            f"تعداد سفارش های مشتری: {orders_count}"
        )
        
    builder = InlineKeyboardBuilder()
    builder.button(text="✅ انجام شد", callback_data=f"order_done_{order.id}_{user.telegram_id}", style="success")
    group_id = await get_group_id(session, "orders", config.fulfillment_group_id)
    try:
        await bot.send_message(chat_id=group_id, text=p_em(admin_text), reply_markup=builder.as_markup())
    except Exception:
        pass

@router.callback_query(F.data.startswith("buy_"))
async def process_purchase(callback: CallbackQuery, state: FSMContext):
    parts = callback.data.split("_")
    prod_id = int(parts[1])
    qty = int(parts[2]) if len(parts) > 2 else 1
    user_id = callback.from_user.id
    
    async with AsyncSessionLocal() as session:
        prod = await get_product_by_id(session, prod_id)
        user = await get_user_by_telegram_id(session, user_id)
        category = await session.get(Category, prod.category_id) if prod else None
        
        if not prod or not user or not category:
            return await callback.answer("خطایی رخ داد.", show_alert=True)
            
        total_price = prod.price * qty
            
        # Check purchase limit condition for document KYC verification (admins are exempt)
        from database.crud import ensure_runtime_admin, get_setting
        is_admin = await ensure_runtime_admin(session, user_id)
        kyc_req = await get_setting(session, "kyc_required", "false")
        if kyc_req == "true" and total_price > 1000000 and not user.is_verified and not is_admin:
            return await callback.answer(
                "⚠️ کاربر گرامی، برای خریدهای بالای ۱,۰۰۰,۰۰۰ تومان احراز هویت با مدارک (ارسال تصویر کارت ملی) الزامی است.\n\n"
                "لطفاً ابتدا از منوی اصلی ربات اقدام به ارسال مدارک کنید.",
                show_alert=True
            )
            
        if prod.stock != -1 and prod.stock < qty:
            return await callback.answer("❌ موجودی این محصول کمتر از مقدار درخواستی است.", show_alert=True)
            
        parent_category = None
        if category and category.parent_id:
            parent_category = await session.get(Category, category.parent_id)
            
        cat_full_name = category.name if category else ""
        if parent_category:
            cat_full_name += " " + parent_category.name
            
        prod_type = get_product_type(cat_full_name, prod.name)

        if prod_type == "redeem":
            await send_payment_options(callback, state, user, prod, qty)
            await callback.answer()
            return

    # ذخیره داده‌های موقت و انتقال به استیت‌های مربوطه
    await state.update_data(prod_id=prod.id, qty=qty, prod_type=prod_type)
    
    saved_id = getattr(user, "saved_player_id", None)
    
    if prod_type == "pubg":
        builder = InlineKeyboardBuilder()
        if saved_id:
            builder.button(text=f"🎮 استفاده از آیدی قبلی: {saved_id}", callback_data=f"use_saved_id_{saved_id}")
        builder.button(text="❌ انصراف", callback_data="back_to_main", style="danger")
        builder.adjust(1)
        await callback.message.edit_text(
            p_em(f"🎮 <b>آیدی عددی پابجی موبایل</b>\n\n"
            f"لطفاً آیدی عددی بازی (Player ID) خود را برای خرید {qty} عدد {prod.name} وارد کنید:"),
            reply_markup=builder.as_markup()
        )
        await state.set_state(ShopState.waiting_for_player_id)
    elif prod_type == "cod":
        builder = InlineKeyboardBuilder()
        builder.button(text="❌ انصراف", callback_data="back_to_main", style="danger")
        await callback.message.edit_text(
            p_em(f"📧 <b>اطلاعات اکانت کالاف دیوتی موبایل (مرحله ۱ از ۳)</b>\n\n"
            f"لطفاً <b>ایمیل، لینک یا شناسه اکتیویژن</b> خود را برای خرید {qty} عدد {prod.name} وارد کنید:"),
            reply_markup=builder.as_markup()
        )
        await state.set_state(ShopState.waiting_for_cod_email)
    elif prod_type == "manual":
        builder = InlineKeyboardBuilder()
        builder.button(text="❌ انصراف", callback_data="back_to_main", style="danger")
        await callback.message.edit_text(
            p_em(f"📧 <b>اطلاعات اکانت (مرحله ۱ از ۲)</b>\n\n"
            f"لطفاً <b>ایمیل اکانت</b> خود را برای خرید {qty} عدد {prod.name} وارد کنید:"),
            reply_markup=builder.as_markup()
        )
        await state.set_state(ShopState.waiting_for_manual_email)
    else:
        # سایر آیتم‌های دستی
        builder = InlineKeyboardBuilder()
        if saved_id:
            builder.button(text=f"🎮 استفاده از آیدی قبلی: {saved_id}", callback_data=f"use_saved_id_{saved_id}")
        builder.button(text="❌ انصراف", callback_data="back_to_main", style="danger")
        builder.adjust(1)
        await callback.message.edit_text(
            p_em(f"🎮 <b>اطلاعات سفارش</b>\n\n"
            f"لطفاً اطلاعات اکانت یا آیدی بازی خود را برای خرید {qty} عدد {prod.name} وارد کنید:"),
            reply_markup=builder.as_markup()
        )
        await state.set_state(ShopState.waiting_for_player_id)
        
    await callback.answer()

# --- Call of Duty FSM flow ---

@router.message(ShopState.waiting_for_cod_email)
async def process_cod_email(message: Message, state: FSMContext):
    email = message.text.strip()
    if len(email) < 4:
        builder = InlineKeyboardBuilder()
        builder.button(text="❌ انصراف", callback_data="back_to_main", style="danger")
        await message.answer(p_em("⚠️ مقدار وارد شده نامعتبر است. لطفاً ایمیل، لینک یا شناسه اکتیویژن خود را مجدداً وارد کنید:"), reply_markup=builder.as_markup())
        return
        
    await state.update_data(cod_email=email)
    
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ انصراف", callback_data="back_to_main", style="danger")
    await message.answer(
        p_em("🔑 <b>اطلاعات اکانت کالاف دیوتی موبایل (مرحله ۲ از ۳)</b>\n\n"
        "لطفاً <b>رمز عبور اکتیویژن</b> خود را وارد کنید:"),
        reply_markup=builder.as_markup()
    )
    await state.set_state(ShopState.waiting_for_cod_password)

@router.message(ShopState.waiting_for_cod_password)
async def process_cod_password(message: Message, state: FSMContext):
    password = message.text.strip()
    if len(password) < 4:
        builder = InlineKeyboardBuilder()
        builder.button(text="❌ انصراف", callback_data="back_to_main", style="danger")
        await message.answer(p_em("⚠️ رمز عبور خیلی کوتاه است. لطفاً مجدداً رمز عبور اکتیویژن خود را وارد کنید:"), reply_markup=builder.as_markup())
        return
        
    await state.update_data(cod_password=password)
    
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ انصراف", callback_data="back_to_main", style="danger")
    await message.answer(
        p_em("🎮 <b>اطلاعات اکانت کالاف دیوتی موبایل (مرحله ۳ از ۳)</b>\n\n"
        "لطفاً <b>آیدی بازی (Game ID)</b> خود را وارد کنید:"),
        reply_markup=builder.as_markup()
    )
    await state.set_state(ShopState.waiting_for_cod_id)

@router.message(ShopState.waiting_for_cod_id)
async def process_cod_id(message: Message, state: FSMContext):
    cod_id = message.text.strip()
    data = await state.get_data()
    prod_id = data.get("prod_id")
    qty = data.get("qty", 1)
    cod_email = data.get("cod_email")
    cod_password = data.get("cod_password")
    user_id = message.from_user.id
    
    async with AsyncSessionLocal() as session:
        prod = await get_product_by_id(session, prod_id)
        user = await get_user_by_telegram_id(session, user_id)
        
        if not prod or not user:
            await state.clear()
            return await message.answer(p_em("❌ خطایی رخ داد. مجدداً تلاش کنید."))
            
    details = {
        "cod_email": cod_email,
        "cod_password": cod_password,
        "cod_id": cod_id
    }
    await send_payment_options(message, state, user, prod, qty, details)

# --- Manual Game FSM flow ---

@router.message(ShopState.waiting_for_manual_email)
async def process_manual_email(message: Message, state: FSMContext):
    email = message.text.strip()
    if "@" not in email or "." not in email:
        builder = InlineKeyboardBuilder()
        builder.button(text="❌ انصراف", callback_data="back_to_main", style="danger")
        await message.answer(p_em("⚠️ ایمیل وارد شده نامعتبر است. لطفاً مجدداً ایمیل اکانت خود را وارد کنید:"), reply_markup=builder.as_markup())
        return
        
    await state.update_data(manual_email=email)
    
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ انصراف", callback_data="back_to_main", style="danger")
    await message.answer(
        p_em("🔑 <b>اطلاعات اکانت (مرحله ۲ از ۲)</b>\n\n"
        "لطفاً <b>رمز عبور اکانت</b> خود را وارد کنید:"),
        reply_markup=builder.as_markup()
    )
    await state.set_state(ShopState.waiting_for_manual_password)

@router.message(ShopState.waiting_for_manual_password)
async def process_manual_password(message: Message, state: FSMContext):
    password = message.text.strip()
    if len(password) < 4:
        builder = InlineKeyboardBuilder()
        builder.button(text="❌ انصراف", callback_data="back_to_main", style="danger")
        await message.answer(p_em("⚠️ رمز عبور خیلی کوتاه است. لطفاً مجدداً رمز عبور خود را وارد کنید:"), reply_markup=builder.as_markup())
        return
        
    data = await state.get_data()
    prod_id = data.get("prod_id")
    qty = data.get("qty", 1)
    manual_email = data.get("manual_email")
    user_id = message.from_user.id
    
    async with AsyncSessionLocal() as session:
        prod = await get_product_by_id(session, prod_id)
        user = await get_user_by_telegram_id(session, user_id)
        
        if not prod or not user:
            await state.clear()
            return await message.answer(p_em("❌ خطایی رخ داد. مجدداً تلاش کنید."))
            
    details = {
        "manual_email": manual_email,
        "manual_password": password
    }
    await send_payment_options(message, state, user, prod, qty, details)

# --- PUBG and other Player ID FSM ---

@router.message(ShopState.waiting_for_player_id)
async def process_player_id(message: Message, state: FSMContext):
    player_id = message.text.strip()
    
    # بررسی مسدود بودن آیدی بازی
    async with AsyncSessionLocal() as session:
        from database.models import BannedPlayer
        stmt = select(BannedPlayer).where(BannedPlayer.player_id == player_id)
        banned_check = (await session.execute(stmt)).scalar_one_or_none()
        if banned_check:
            builder = InlineKeyboardBuilder()
            builder.button(text="❌ انصراف", callback_data="back_to_main", style="danger")
            return await message.answer(
                p_em("❌ <b>آیدی بازی مسدود شده است!</b>\n\n"
                "امکان ثبت سفارش برای این آیدی بازی به دلیل تخلف وجود ندارد. لطفا آیدی دیگری وارد کنید یا با پشتیبانی در ارتباط باشید:"),
                reply_markup=builder.as_markup()
            )
            
    data = await state.get_data()
    prod_id = data.get("prod_id")
    qty = data.get("qty", 1)
    prod_type = data.get("prod_type", "other")
    user_id = message.from_user.id
    
    async with AsyncSessionLocal() as session:
        prod = await get_product_by_id(session, prod_id)
        user = await get_user_by_telegram_id(session, user_id)
        
        if not prod or not user:
            await state.clear()
            return await message.answer("❌ خطایی رخ داد. مجدداً تلاش کنید.")
        total_price = prod.price * qty
            
    if prod_type == "pubg":
        # دریافت مشخصات بازیکن پابجی از API
        await message.answer(p_em("🔍 در حال استعلام اطلاعات بازیکن از Midasbuy..."))
        player_name = await fetch_pubg_player_name(player_id)
        
        if not player_name:
            builder = InlineKeyboardBuilder()
            builder.button(text="❌ انصراف", callback_data="back_to_main", style="danger")
            await message.answer(
                p_em("❌ <b>آیدی بازیکن یافت نشد!</b>\n\n"
                "سایت Midasbuy بازیکنی با این آیدی پیدا نکرد. لطفاً آیدی عددی بازی خود را مجدداً بررسی کرده و با دقت ارسال کنید:"),
                reply_markup=builder.as_markup()
            )
            return
            
        # ذخیره موقت مشخصات و تایید هویت کاربر بازی
        await state.update_data(player_id=player_id, player_name=player_name)
        
        # ذخیره آیدی در دیتابیس برای استفاده‌های بعدی
        async with AsyncSessionLocal() as session:
            user_db = await get_user_by_telegram_id(session, user_id)
            if user_db:
                user_db.saved_player_id = player_id
                await session.commit()
        
        builder = InlineKeyboardBuilder()
        builder.button(text="✅ بله، تایید و پرداخت", callback_data="pubg_confirm_pay", style="success")
        builder.button(text="❌ خیر، تغییر آیدی", callback_data="pubg_change_id", style="danger")
        builder.adjust(1)
        
        await message.answer(
            p_em(f"👤 <b>تایید اطلاعات بازیکن پابجی</b>\n"
            f"〰️〰️〰️〰️〰️〰️〰️\n"
            f"🎮 <b>نام مستعار در بازی:</b> {player_name}\n"
            f"🆔 <b>آیدی عددی:</b> <code>{player_id}</code>\n\n"
            f"💵 <b>مبلغ کل کسر شده:</b> {total_price:,.0f} تومان\n\n"
            f"آیا مایلید این سفارش ثبت و پرداخت شود؟"),
            reply_markup=builder.as_markup()
        )
    else:
        # سایر بازی‌ها (واریز دستی)
        async with AsyncSessionLocal() as session:
            prod = await get_product_by_id(session, prod_id)
            user = await get_user_by_telegram_id(session, user_id)
            
            if not prod or not user:
                await state.clear()
                return await message.answer("❌ خطایی رخ داد. مجدداً تلاش کنید.")
            
            # ذخیره آیدی در دیتابیس برای استفاده‌های بعدی
            user.saved_player_id = player_id
            await session.commit()
                
        details = {
            "player_id": player_id
        }
        await send_payment_options(message, state, user, prod, qty, details)

@router.callback_query(F.data == "pubg_change_id")
async def pubg_change_id(callback: CallbackQuery, state: FSMContext):
    data = await state.get_data()
    prod_id = data.get("prod_id")
    qty = data.get("qty", 1)
    user_id = callback.from_user.id
    
    async with AsyncSessionLocal() as session:
        prod = await get_product_by_id(session, prod_id)
        user = await get_user_by_telegram_id(session, user_id)
        
    builder = InlineKeyboardBuilder()
    saved_id = getattr(user, "saved_player_id", None) if user else None
    if saved_id:
        builder.button(text=f"🎮 استفاده از آیدی قبلی: {saved_id}", callback_data=f"use_saved_id_{saved_id}")
    builder.button(text="❌ انصراف", callback_data="back_to_main", style="danger")
    builder.adjust(1)
    await callback.message.edit_text(
        f"🎮 <b>آیدی عددی پابجی موبایل</b>\n\n"
        f"لطفاً آیدی عددی بازی (Player ID) خود را برای خرید {qty} عدد {prod.name if prod else ''} مجدداً وارد کنید:",
        reply_markup=builder.as_markup()
    )
    await state.set_state(ShopState.waiting_for_player_id)
    await callback.answer()

@router.callback_query(F.data.startswith("use_saved_id_"))
async def use_saved_id_callback(callback: CallbackQuery, state: FSMContext):
    player_id = callback.data.split("_")[3]
    
    # بررسی مسدود بودن آیدی بازی
    async with AsyncSessionLocal() as session:
        from database.models import BannedPlayer
        stmt = select(BannedPlayer).where(BannedPlayer.player_id == player_id)
        banned_check = (await session.execute(stmt)).scalar_one_or_none()
        if banned_check:
            await callback.answer("❌ این آیدی بازی به دلیل تخلف مسدود شده است!", show_alert=True)
            return
    data = await state.get_data()
    prod_id = data.get("prod_id")
    qty = data.get("qty", 1)
    prod_type = data.get("prod_type", "other")
    user_id = callback.from_user.id
    
    async with AsyncSessionLocal() as session:
        prod = await get_product_by_id(session, prod_id)
        user = await get_user_by_telegram_id(session, user_id)
        
        if not prod or not user:
            await state.clear()
            return await callback.message.answer("❌ خطایی رخ داد. مجدداً تلاش کنید.")
        total_price = prod.price * qty
            
    if prod_type == "pubg":
        await callback.message.answer(p_em("🔍 در حال استعلام اطلاعات بازیکن از Midasbuy..."))
        player_name = await fetch_pubg_player_name(player_id)
        
        if not player_name:
            builder = InlineKeyboardBuilder()
            builder.button(text="❌ انصراف", callback_data="back_to_main", style="danger")
            await callback.message.answer(
                p_em("❌ <b>آیدی بازیکن یافت نشد!</b>\n\n"
                "سایت Midasbuy بازیکنی با این آیدی پیدا نکرد. لطفاً آیدی عددی بازی خود را مجدداً بررسی کرده و با دقت ارسال کنید:"),
                reply_markup=builder.as_markup()
            )
            await callback.answer()
            return
            
        await state.update_data(player_id=player_id, player_name=player_name)
        
        # ذخیره آیدی در دیتابیس (تایید شده)
        async with AsyncSessionLocal() as session:
            user_db = await get_user_by_telegram_id(session, user_id)
            if user_db:
                user_db.saved_player_id = player_id
                await session.commit()
        
        builder = InlineKeyboardBuilder()
        builder.button(text="✅ بله، تایید و پرداخت", callback_data="pubg_confirm_pay", style="success")
        builder.button(text="❌ خیر، تغییر آیدی", callback_data="pubg_change_id", style="danger")
        builder.adjust(1)
        
        await callback.message.answer(
            p_em(f"👤 <b>تایید اطلاعات بازیکن پابجی</b>\n"
            f"〰️〰️〰️〰️〰️〰️〰️\n"
            f"🎮 <b>نام مستعار در بازی:</b> {player_name}\n"
            f"🆔 <b>آیدی عددی:</b> <code>{player_id}</code>\n\n"
            f"💵 <b>مبلغ کل کسر شده:</b> {total_price:,.0f} تومان\n\n"
            f"آیا مایلید این سفارش ثبت و پرداخت شود؟"),
            reply_markup=builder.as_markup()
        )
    else:
        # سایر بازی‌ها (واریز دستی)
        async with AsyncSessionLocal() as session:
            user_db = await get_user_by_telegram_id(session, user_id)
            if user_db:
                user_db.saved_player_id = player_id
                await session.commit()
                
        details = {
            "player_id": player_id
        }
        await send_payment_options(callback.message, state, user, prod, qty, details)
        
    await callback.answer()


@router.callback_query(F.data == "pubg_confirm_pay")
async def pubg_confirm_pay(callback: CallbackQuery, state: FSMContext):
    data = await state.get_data()
    prod_id = data.get("prod_id")
    qty = data.get("qty", 1)
    player_id = data.get("player_id")
    player_name = data.get("player_name")
    user_id = callback.from_user.id
    
    async with AsyncSessionLocal() as session:
        prod = await get_product_by_id(session, prod_id)
        user = await get_user_by_telegram_id(session, user_id)
        
        if not prod or not user:
            await state.clear()
            return await callback.message.edit_text("❌ خطایی رخ داد. لطفاً مجدداً خرید را شروع کنید.")
            
        total_price = prod.price * qty
        if prod.stock != -1 and prod.stock < qty:
            await state.clear()
            return await callback.message.edit_text("❌ موجودی این محصول کمتر از مقدار درخواستی است.")
            
    details = {
        "player_id": player_id,
        "player_name": player_name
    }
    await send_payment_options(callback, state, user, prod, qty, details)

# --- پردازش پرداخت‌ها ---

@router.callback_query(F.data == "pay_opt_wallet")
async def pay_checkout_wallet(callback: CallbackQuery, state: FSMContext):
    data = await state.get_data()
    prod_id = data.get("checkout_prod_id")
    qty = data.get("checkout_qty", 1)
    details_str = data.get("checkout_details", "{}")
    user_id = callback.from_user.id
    
    async with AsyncSessionLocal() as session:
        prod = await get_product_by_id(session, prod_id)
        user = await get_user_by_telegram_id(session, user_id)
        
        if not prod or not user:
            await state.clear()
            return await callback.message.edit_text("❌ خطایی رخ داد. مجدداً خرید را شروع کنید.")
            
        total_price = prod.price * qty
        if user.wallet_balance < total_price:
            return await callback.answer("❌ موجودی کیف پول شما کافی نیست!", show_alert=True)
            
        if prod.stock != -1 and prod.stock < qty:
            return await callback.answer("❌ موجودی این محصول کمتر از مقدار درخواستی است.", show_alert=True)
            
        # کسر موجودی و ثبت
        user.wallet_balance -= total_price
        
        from database.models import Transaction
        new_tx = Transaction(user_id=user.id, amount=-total_price, type="purchase")
        session.add(new_tx)
        
        new_order = Order(
            user_id=user.id,
            product_id=prod.id,
            quantity=qty,
            amount=total_price,
            status="pending",
            details=details_str,
            payment_method="wallet",
            midasbuy_status="paid",
            midasbuy_payload=json.dumps({"source": "wallet", "status": "paid"}, ensure_ascii=False)
        )
        session.add(new_order)
        await session.flush()
        
        record_midasbuy_event(new_order, "paid", {"source": "wallet", "status": "paid"})
        await fulfill_order(session, callback.bot, new_order, user, prod)
        
    await state.clear()
    await callback.answer()

@router.callback_query(F.data == "pay_opt_zibal")
async def pay_checkout_zibal(callback: CallbackQuery, state: FSMContext):
    data = await state.get_data()
    prod_id = data.get("checkout_prod_id")
    qty = data.get("checkout_qty", 1)
    details_str = data.get("checkout_details", "{}")
    user_id = callback.from_user.id
    
    async with AsyncSessionLocal() as session:
        prod = await get_product_by_id(session, prod_id)
        user = await get_user_by_telegram_id(session, user_id)
        zibal_enabled = await get_setting(session, "zibal_enabled", "true")
        
        if not prod or not user:
            await state.clear()
            return await callback.message.edit_text("❌ خطایی رخ داد. مجدداً خرید را شروع کنید.")

        if zibal_enabled != "true":
            return await callback.answer("❌ پرداخت زیبال در حال حاضر غیرفعال است.", show_alert=True)
            
        total_price = prod.price * qty
        if prod.stock != -1 and prod.stock < qty:
            return await callback.answer("❌ موجودی این محصول کمتر از مقدار درخواستی است.", show_alert=True)
            
        # ثبت فاکتور پرداخت نشده
        new_order = Order(
            user_id=user.id,
            product_id=prod.id,
            quantity=qty,
            amount=total_price,
            status="pending_payment",
            details=details_str,
            payment_method="zibal",
            midasbuy_status="created",
            midasbuy_payload=json.dumps({"source": "zibal", "status": "created"}, ensure_ascii=False)
        )
        session.add(new_order)
        await session.flush()
        order_id = new_order.id
        
        # دریافت درگاه زیبال
        merchant = await get_setting(session, "zibal_merchant", "zibal")
        callback_url = await get_setting(session, "zibal_callback_url", "https://solso.ir/mohsenP/verify.php")
        
        await session.commit()
        
    # درخواست درگاه زیبال
    from services.zibal_service import request_zibal_payment
    bot_info = await callback.bot.get_me()
    
    await callback.message.edit_text(p_em("⚡️ در حال تولید لینک پرداخت زیبال..."))
    
    res = await request_zibal_payment(
        merchant=merchant,
        amount_toman=int(total_price),
        callback_url=callback_url,
        description=f"سفارش شماره {order_id} در ربات"
    )
    
    if res.get("status"):
        payment_url = res["payment_url"]
        track_id = res["track_id"]
        
        # ثبت کد رهگیری در دیتابیس برای بازیابی در آینده
        async with AsyncSessionLocal() as session:
            db_order = await session.get(Order, order_id)
            if db_order:
                db_order.midasbuy_order_no = str(track_id)
                db_order.midasbuy_payload = json.dumps({"source": "zibal", "track_id": track_id, "status": "created"}, ensure_ascii=False)
                await session.commit()
        
        builder = InlineKeyboardBuilder()
        builder.button(text="💳 پرداخت آنلاین زیبال", url=payment_url)
        builder.button(text="✅ بررسی پرداخت", callback_data=f"chk_zibal_{order_id}_{track_id}", style="primary")
        builder.button(text="❌ انصراف", callback_data=f"cncl_ord_{order_id}", style="danger")
        builder.adjust(1)
        
        await callback.message.edit_text(
            p_em(f"💳 <b>درگاه پرداخت زیبال صادر شد</b>\n"
            f"〰️〰️〰️〰️〰️〰️〰️\n"
            f"💵 <b>مبلغ پرداخت:</b> {total_price:,.0f} تومان\n"
            f"🏷 <b>شماره سفارش:</b> {order_id}\n\n"
            f"لطفاً پرداخت را از دکمه پرداخت انجام دهید و سپس گزینه «بررسی پرداخت» را بفشارید."),
            reply_markup=builder.as_markup()
        )
    else:
        await callback.message.edit_text(p_em(f"❌ خطا در ایجاد لینک پرداخت: {res.get('message')}\nلطفاً بعداً تلاش کنید یا با پشتیبانی تماس بگیرید."))
        
    await state.clear()
    await callback.answer()

@router.callback_query(F.data.startswith("chk_zibal_"))
async def verify_checkout_zibal(callback: CallbackQuery):
    _, _, order_id_str, track_id_str = callback.data.split("_")
    order_id = int(order_id_str)
    track_id = int(track_id_str)
    
    async with AsyncSessionLocal() as session:
        order = await session.get(Order, order_id)
        if not order:
            return await callback.answer("سفارش یافت نشد!", show_alert=True)
            
        if order.status != "pending_payment":
            return await callback.answer("این سفارش قبلاً پرداخت/تعیین وضعیت شده است.", show_alert=True)
            
        user = await session.get(User, order.user_id)
        prod = await session.get(Product, order.product_id)
        
        # دریافت مرچنت
        merchant = await get_setting(session, "zibal_merchant", "zibal")
        
        from services.zibal_service import verify_zibal_payment
        res = await verify_zibal_payment(merchant, track_id)
        
        if res.get("status"):
            # ثبت تراکنش موفق
            from database.models import Transaction
            new_tx = Transaction(user_id=user.id, amount=order.amount, type="rial_charge")
            session.add(new_tx)
            
            new_tx2 = Transaction(user_id=user.id, amount=-order.amount, type="purchase")
            session.add(new_tx2)
            
            await session.flush()
            
            # تحویل سفارش
            record_midasbuy_event(order, "paid", {"source": "zibal", "track_id": track_id, "status": "paid"})
            await fulfill_order(session, callback.bot, order, user, prod)
            await session.commit()
            await callback.answer("پرداخت تایید شد و سفارش ثبت گردید ✅", show_alert=True)
        else:
            await callback.answer(f"❌ خطا در تایید پرداخت: {res.get('message')}", show_alert=True)

@router.callback_query(F.data == "pay_opt_usdt")
async def pay_checkout_usdt(callback: CallbackQuery, state: FSMContext):
    data = await state.get_data()
    prod_id = data.get("checkout_prod_id")
    qty = data.get("checkout_qty", 1)
    details_str = data.get("checkout_details", "{}")
    user_id = callback.from_user.id
    
    async with AsyncSessionLocal() as session:
        prod = await get_product_by_id(session, prod_id)
        user = await get_user_by_telegram_id(session, user_id)
        nowpayments_enabled = await get_setting(session, "nowpayments_enabled", "true")
        
        if not prod or not user:
            await state.clear()
            return await callback.message.edit_text(p_em("❌ خطایی رخ داد. مجدداً خرید را شروع کنید."))

        if nowpayments_enabled != "true":
            return await callback.answer("❌ پرداخت تتری در حال حاضر غیرفعال است.", show_alert=True)
            
        total_price = prod.price * qty
        if prod.stock != -1 and prod.stock < qty:
            return await callback.answer("❌ موجودی این محصول کمتر از مقدار درخواستی است.", show_alert=True)
            
        # ثبت فاکتور پرداخت نشده
        new_order = Order(
            user_id=user.id,
            product_id=prod.id,
            quantity=qty,
            amount=total_price,
            status="pending_payment",
            details=details_str,
            payment_method="usdt",
            midasbuy_status="created",
            midasbuy_payload=json.dumps({"source": "nowpayments", "status": "created"}, ensure_ascii=False)
        )
        session.add(new_order)
        await session.flush()
        order_id = new_order.id
        await session.commit()
        
    # ایجاد فاکتور NowPayments
    from services.nowpayments_service import create_invoice
    async with AsyncSessionLocal() as session:
        usdt_rate = float(await get_setting(session, "usdt_rate", "60000"))
    usd_amount = round(total_price / usdt_rate, 2)
    order_id_now = f"checkout_{order_id}"
    
    await callback.message.edit_text(p_em("⚡️ در حال تولید فاکتور تتری..."))
    result = await create_invoice(usd_amount, order_id_now, f"Order #{order_id} purchase")
    
    if result["status"]:
        payment_id = result["payment_id"]
        builder = InlineKeyboardBuilder()
        builder.button(text="💳 پرداخت فاکتور تتری", url=result["invoice_url"])
        builder.button(text="✅ بررسی پرداخت تتر", callback_data=f"chk_usdt_{order_id}_{payment_id}", style="primary")
        builder.button(text="❌ انصراف", callback_data=f"cncl_ord_{order_id}", style="danger")
        builder.adjust(1)
        
        await callback.message.edit_text(
            p_em(f"🪙 <b>فاکتور پرداخت تتری (USDT TRC20)</b>\n"
            f"〰️〰️〰️〰️〰️〰️〰️\n"
            f"💵 <b>مبلغ معادل:</b> {total_price:,.0f} تومان\n"
            f"🪙 <b>مبلغ تتری:</b> {usd_amount} USDT\n"
            f"🏷 <b>شماره سفارش:</b> {order_id}\n\n"
            f"لطفاً پرداخت را در درگاه انجام داده و پس از واریز روی دکمه «بررسی وضعیت» کلیک کنید."),
            reply_markup=builder.as_markup()
        )
    else:
        await callback.message.edit_text(p_em("❌ خطا در ایجاد درگاه NowPayments. مجدداً تلاش کنید."))
        
    await state.clear()
    await callback.answer()

@router.callback_query(F.data.startswith("chk_usdt_"))
async def verify_checkout_usdt(callback: CallbackQuery):
    _, _, order_id_str, payment_id = callback.data.split("_")
    order_id = int(order_id_str)
    
    async with AsyncSessionLocal() as session:
        order = await session.get(Order, order_id)
        if not order:
            return await callback.answer("سفارش یافت نشد!", show_alert=True)
            
        if order.status != "pending_payment":
            return await callback.answer("این سفارش قبلاً پرداخت/تعیین وضعیت شده است.", show_alert=True)
            
        user = await session.get(User, order.user_id)
        prod = await session.get(Product, order.product_id)
        
        from services.nowpayments_service import check_payment_status
        status = await check_payment_status(payment_id)
        
        if status in ["finished", "confirmed"]:
            from database.models import Transaction
            new_tx = Transaction(user_id=user.id, amount=order.amount, type="usdt_charge")
            session.add(new_tx)
            
            new_tx2 = Transaction(user_id=user.id, amount=-order.amount, type="purchase")
            session.add(new_tx2)
            
            await session.flush()
            record_midasbuy_event(order, "paid", {"source": "nowpayments", "payment_id": payment_id, "status": "paid"})
            await fulfill_order(session, callback.bot, order, user, prod)
            await callback.answer("پرداخت تتری تایید شد و سفارش ثبت گردید ✅", show_alert=True)
        elif status in ["waiting", "confirming", "sending"]:
            await callback.answer("⏳ پرداخت شما هنوز تایید نهایی نشده است. لطفاً چند دقیقه دیگر بررسی کنید.", show_alert=True)
        else:
            await callback.answer(f"وضعیت فاکتور: {status} ❌", show_alert=True)

@router.callback_query(F.data == "pay_opt_receipt")
async def pay_checkout_receipt(callback: CallbackQuery, state: FSMContext):
    data = await state.get_data()
    prod_id = data.get("checkout_prod_id")
    qty = data.get("checkout_qty", 1)
    details_str = data.get("checkout_details", "{}")
    user_id = callback.from_user.id
    
    async with AsyncSessionLocal() as session:
        prod = await get_product_by_id(session, prod_id)
        user = await get_user_by_telegram_id(session, user_id)
        
        if not prod or not user:
            await state.clear()
            return await callback.message.edit_text("❌ خطایی رخ داد. مجدداً خرید را شروع کنید.")
            
        total_price = prod.price * qty
        if prod.stock != -1 and prod.stock < qty:
            return await callback.answer("❌ موجودی این محصول کمتر از مقدار درخواستی است.", show_alert=True)
            
        # ثبت فاکتور
        new_order = Order(
            user_id=user.id,
            product_id=prod.id,
            quantity=qty,
            amount=total_price,
            status="pending_payment",
            details=details_str,
            payment_method="receipt",
            midasbuy_status="created",
            midasbuy_payload=json.dumps({"source": "receipt", "status": "created"}, ensure_ascii=False)
        )
        session.add(new_order)
        await session.flush()
        order_id = new_order.id
        card_number = await get_setting(session, "card_number", "تنظیم نشده")
        card_name = await get_setting(session, "card_name", "تنظیم نشده")
        await session.commit()
        
    await state.update_data(receipt_order_id=order_id)
    
    builder = InlineKeyboardBuilder()
    builder.button(text="❌ انصراف", callback_data=f"cncl_ord_{order_id}", style="danger")
    
    await callback.message.edit_text(
        p_em(f"💳 <b>پرداخت کارت به کارت</b>\n\n"
        f"مبلغ قابل پرداخت: {total_price:,.0f} تومان\n"
        f"لطفاً مبلغ فوق را به شماره کارت زیر واریز کنید:\n\n"
        f"💳 <code>{card_number}</code>\n"
        f"👤 به نام: {card_name}\n\n"
        f"📸 <b>سپس عکس رسید پرداختی خود را همینجا ارسال کنید.</b>"),
        reply_markup=builder.as_markup()
    )
    await state.set_state(ShopState.waiting_for_receipt_upload)
    await callback.answer()

@router.message(ShopState.waiting_for_receipt_upload, F.photo)
async def receipt_received(message: Message, state: FSMContext):
    data = await state.get_data()
    order_id = data.get("receipt_order_id")
    
    if not order_id:
        return await message.reply("سفارشی یافت نشد! لطفاً مجدداً تلاش کنید.")
        
    photo_file_id = message.photo[-1].file_id
    
    async with AsyncSessionLocal() as session:
        order = await session.get(Order, order_id)
        prod = await get_product_by_id(session, order.product_id)
        if not order or not prod:
            await state.clear()
            return await message.reply("خطا در یافتن اطلاعات سفارش.")
            
        user = await get_user_by_telegram_id(session, message.from_user.id)
        
        # تغییر وضعیت سفارش به pending_approval
        order.status = "pending_approval"
        await session.commit()
        
        builder = InlineKeyboardBuilder()
        builder.button(text="✅ تایید فیش و ثبت نهایی", callback_data=f"adm_appr_rcpt_{order.id}", style="success")
        builder.button(text="❌ رد فیش", callback_data=f"adm_rej_rcpt_{order.id}", style="danger")
        
        admin_caption = (
            f"🧾 <b>فیش پرداختی جدید (فروشگاه)</b>\n"
            f"👤 کاربر: {message.from_user.full_name} (@{message.from_user.username})\n"
            f"🆔 آیدی: <code>{message.from_user.id}</code>\n"
            f"احراز هویت: {'1' if user.is_verified else '0'}\n\n"
            f"📦 سفارش: #{order.id} - {prod.name} (تعداد {order.quantity})\n"
            f"💵 مبلغ فیش: {order.amount:,.0f} تومان"
        )
        
        # دریافت داینامیک آیدی گروه فیش‌ها
        group_id = await get_group_id(session, "receipts", config.admin_group_id)
        
        try:
            await message.bot.send_photo(
                chat_id=group_id,
                photo=photo_file_id,
                caption=admin_caption,
                reply_markup=builder.as_markup()
            )
            await message.answer(p_em("⏳ فیش واریزی شما با موفقیت برای پشتیبانی ارسال شد. پس از بررسی نتیجه به اطلاع شما خواهد رسید."))
        except Exception as e:
            await message.answer(p_em("❌ خطا در ارسال فیش به پشتیبانی. لطفاً با پشتیبانی ارتباط برقرار کنید."))
            
    await state.clear()
    from handlers.user_panel import cmd_start
    await cmd_start(message, state)

@router.message(ShopState.waiting_for_receipt_upload)
async def process_checkout_receipt_invalid(message: Message):
    await message.answer(p_em("⚠️ لطفاً تصویر فیش واریزی خود را به صورت عکس ارسال کنید."))

@router.callback_query(F.data.startswith("adm_appr_rcpt_"))
async def admin_approve_checkout_receipt(callback: CallbackQuery):
    order_id = int(callback.data.split("_")[3])
    
    async with AsyncSessionLocal() as session:
        order = await session.get(Order, order_id)
        if not order or order.status != "pending_approval":
            return await callback.answer("سفارش قبلاً تعیین وضعیت شده یا یافت نشد.", show_alert=True)
            
        user = await session.get(User, order.user_id)
        prod = await session.get(Product, order.product_id)
        
        # ثبت در تراکنش‌ها
        from database.models import Transaction
        new_tx = Transaction(user_id=user.id, amount=order.amount, type="rial_charge")
        session.add(new_tx)
        
        new_tx2 = Transaction(user_id=user.id, amount=-order.amount, type="purchase")
        session.add(new_tx2)
        
        await session.flush()
        
        # تحویل سفارش
        record_midasbuy_event(order, "paid", {"source": "receipt", "status": "paid"})
        await fulfill_order(session, callback.bot, order, user, prod)
        await session.commit()
        
    await callback.message.edit_reply_markup(reply_markup=None)
    await callback.message.reply(p_em(f"✅ فیش سفارش {order_id} توسط ادمین تایید و سفارش پردازش شد."))
    await callback.answer("تایید شد")

@router.callback_query(F.data.startswith("adm_rej_rcpt_"))
async def admin_reject_checkout_receipt(callback: CallbackQuery):
    order_id = int(callback.data.split("_")[3])
    
    async with AsyncSessionLocal() as session:
        order = await session.get(Order, order_id)
        if not order or order.status != "pending_approval":
            return await callback.answer("سفارش قبلاً تعیین وضعیت شده یا یافت نشد.", show_alert=True)
            
        order.status = "rejected"
        record_midasbuy_event(order, "payment_failed", {"source": "receipt", "status": "payment_failed"})
        user_telegram_id = (await session.get(User, order.user_id)).telegram_id
        await session.commit()
        
    try:
        await callback.bot.send_message(
            chat_id=user_telegram_id,
            text=p_em(f"❌ متاسفانه فیش واریزی شما برای سفارش #{order_id} رد شد. در صورت لزوم با پشتیبانی تماس بگیرید.")
        )
    except:
        pass
        
    await callback.message.edit_reply_markup(reply_markup=None)
    await callback.message.reply(p_em(f"❌ فیش سفارش {order_id} توسط ادمین رد شد."))
    await callback.answer("رد شد")

@router.callback_query(F.data.startswith("cncl_ord_"))
async def cancel_pending_order(callback: CallbackQuery, state: FSMContext = None):
    if state:
        await state.clear()
    order_id = int(callback.data.split("_")[2])
    async with AsyncSessionLocal() as session:
        order = await session.get(Order, order_id)
        if order and order.status == "pending_payment":
            order.status = "rejected"
            record_midasbuy_event(order, "payment_failed", {"source": "user_cancel", "status": "payment_failed"})
            await session.commit()
            
    await callback.message.edit_text(p_em("❌ سفارش شما لغو شد."))
    await callback.answer("سفارش لغو شد")
    from handlers.user_panel import cmd_start
    await cmd_start(callback.message, state)
