"""
User Handlers (Start, Menu, Wallet, etc.)
"""
import html
import re
from aiogram import Router, F
from aiogram.types import Message, CallbackQuery, InlineKeyboardMarkup, InlineKeyboardButton
from aiogram.filters import CommandStart
from aiogram.filters.callback_data import CallbackData
from aiogram.enums import ChatMemberStatus
from aiogram.exceptions import TelegramBadRequest
from database.db_manager import UserManager, PlansManager, ReferralManager, UISettingsManager, OrderManager
from utils.keyboard_builder import AdvancedKeyboard
from utils.messages import MessageTemplates
from utils.referral_utils import ReferralCodeGenerator
from utils.raw_sender import send_or_edit_with_raw_keyboard
from config.settings import (
    USERS_DB,
    PLANS_DB,
    REFERRALS_DB,
    UI_SETTINGS_DB,
    REFERRAL_REWARD_COINS,
    REFERRAL_THRESHOLD,
    REFERRAL_POINT_PER_USER,
    FREE_REWARD_POINTS_REQUIRED,
    FREE_REWARD_COINS,
    ORDERS_DB,
    ADMIN_ID,
    EMOJI_FIRE,
    EMOJI_GIFT,
)
import uuid
from datetime import datetime

router = Router()
user_manager = UserManager(USERS_DB)
plans_manager = PlansManager(PLANS_DB)
referral_manager = ReferralManager(REFERRALS_DB)
ui_settings_manager = UISettingsManager(UI_SETTINGS_DB)
order_manager = OrderManager(ORDERS_DB)


def _get_points(user: dict) -> float:
    referral_points = user.get('referrals_count', 0) * REFERRAL_POINT_PER_USER
    bonus_points = float(user.get('bonus_points', 0.0))
    total_points = referral_points + bonus_points
    spent = float(user.get('referral_points_spent', 0.0))
    available = total_points - spent
    return round(max(available, 0.0), 2)


def _render_welcome_text(first_name: str) -> str:
    custom = ui_settings_manager.get_welcome_text()
    if custom:
        return custom.replace('{first_name}', first_name)
    return MessageTemplates.welcome(first_name)


def _strip_tg_emoji_tags(text: str) -> str:
    """Remove tg-emoji tags and keep inner emoji/text for fallback delivery."""
    no_wrapped = re.sub(r'<tg-emoji\b[^>]*>(.*?)</tg-emoji>', r'\1', text, flags=re.IGNORECASE | re.DOTALL)
    no_open = re.sub(r'<tg-emoji\b[^>]*>', '', no_wrapped, flags=re.IGNORECASE)
    return no_open.replace('</tg-emoji>', '')


async def _notify_referrer_new_member(
    bot,
    referrer_id: int,
    new_user_id: int,
    new_username: str,
    referrals_count: int,
    reward_coins: int,
):
    """Send a beautiful referral notification when a new member joins via invite link."""
    ref_user = user_manager.get_user(referrer_id) or {}
    total_points = _get_points(ref_user)

    default_tpl = (
        f'<tg-emoji emoji-id="{EMOJI_GIFT}">🎁</tg-emoji> <b>یه کاربر جدید با لینک شما وارد شد!</b>\n\n'
        f'<tg-emoji emoji-id="{EMOJI_FIRE}">🔥</tg-emoji> <b>مشخصات عضو جدید:</b>\n'
        f'• آیدی عددی: <code>{{new_user_id}}</code>\n'
        f'• یوزرنیم: <code>{{new_username}}</code>\n\n'
        f'<tg-emoji emoji-id="{EMOJI_GIFT}">🎁</tg-emoji> <b>جوایز شما:</b>\n'
        f'• امتیاز این دعوت: <code>{{points_earned}}</code>\n'
        f'• مجموع امتیاز قابل استفاده: <code>{{total_points}}</code>\n'
        f'• تعداد کل دعوت موفق: <code>{{referrals_count}}</code>\n'
        f'• کوین پاداش دوره‌ای: <code>{{reward_coins}}</code>'
    )
    template = ui_settings_manager.get_text_template('user_referral_joined', default_tpl)

    context = {
        'new_user_id': new_user_id,
        'new_username': f"@{new_username}" if new_username else 'ندارد',
        'points_earned': REFERRAL_POINT_PER_USER,
        'total_points': total_points,
        'reward_coins': reward_coins,
        'referrals_count': referrals_count,
    }

    has_placeholders = any(
        ph in template for ph in [
            '{new_user_id}', '{new_username}', '{points_earned}',
            '{total_points}', '{reward_coins}', '{referrals_count}'
        ]
    )
    pretty_text = template
    for k, v in context.items():
        pretty_text = pretty_text.replace(f"{{{k}}}", html.escape(str(v)))

    if not has_placeholders:
        pretty_text += (
            "\n\n"
            f"<b>آیدی عددی:</b> <code>{html.escape(str(new_user_id))}</code>\n"
            f"<b>یوزرنیم:</b> <code>{html.escape(str(context['new_username']))}</code>\n"
            f"<b>امتیاز این دعوت:</b> <code>{html.escape(str(REFERRAL_POINT_PER_USER))}</code>\n"
            f"<b>کل امتیاز:</b> <code>{html.escape(str(total_points))}</code>"
        )

    try:
        await bot.send_message(referrer_id, pretty_text, parse_mode="HTML")
    except TelegramBadRequest as exc:
        if "DOCUMENT_INVALID" in str(exc).upper():
            try:
                await bot.send_message(
                    referrer_id,
                    _strip_tg_emoji_tags(pretty_text),
                    parse_mode="HTML",
                )
            except Exception:
                pass


async def _check_force_join(bot, user_id: int):
    cfg = ui_settings_manager.get_force_join()
    if not cfg.get('enabled', False):
        return True, []
    targets = cfg.get('targets', [])
    missing = []
    for target in targets:
        try:
            member = await bot.get_chat_member(chat_id=target, user_id=user_id)
            if member.status in {ChatMemberStatus.LEFT, ChatMemberStatus.KICKED}:
                missing.append(target)
        except TelegramBadRequest:
            missing.append(target)
    return len(missing) == 0, missing


async def _send_force_join_prompt_message(message: Message, missing_targets: list[str]):
    rows = []
    for target in missing_targets:
        rows.append([InlineKeyboardButton(text=f"عضویت در {target}", url=f"https://t.me/{target.lstrip('@')}")])
    rows.append([InlineKeyboardButton(text="✅ بررسی عضویت", callback_data="check_force_join")])
    kb = InlineKeyboardMarkup(inline_keyboard=rows)
    await message.answer(
        "🔒 <b>جوین اجباری فعال است</b>\n\n"
        "برای استفاده از ربات ابتدا در موارد زیر عضو شوید و سپس روی بررسی عضویت بزنید.",
        reply_markup=kb,
        parse_mode="HTML",
    )


async def _send_force_join_prompt_callback(callback: CallbackQuery, missing_targets: list[str]):
    rows = []
    for target in missing_targets:
        rows.append([InlineKeyboardButton(text=f"عضویت در {target}", url=f"https://t.me/{target.lstrip('@')}")])
    rows.append([InlineKeyboardButton(text="✅ بررسی عضویت", callback_data="check_force_join")])
    kb = InlineKeyboardMarkup(inline_keyboard=rows)
    await callback.message.edit_text(
        "🔒 <b>جوین اجباری فعال است</b>\n\n"
        "برای ادامه، ابتدا عضو شوید و دوباره بررسی کنید.",
        reply_markup=kb,
        parse_mode="HTML",
    )


async def _ensure_join_for_callback(callback: CallbackQuery) -> bool:
    ok, missing = await _check_force_join(callback.bot, callback.from_user.id)
    if ok:
        return True
    await _send_force_join_prompt_callback(callback, missing)
    await callback.answer("ابتدا عضو کانال/گروه شوید", show_alert=True)
    return False

# Callback data handlers
class ShopCallback(CallbackData, prefix="shop"):
    action: str


@router.message(CommandStart())
async def cmd_start(message: Message):
    """Handle /start command"""
    user_id = message.from_user.id

    ok, missing = await _check_force_join(message.bot, user_id)
    if not ok:
        await _send_force_join_prompt_message(message, missing)
        return
    
    # Check if user is new
    if not user_manager.user_exists(user_id):
        # Create new user
        referral_code = str(user_id)
        user_manager.create_user(
            user_id=user_id,
            username=message.from_user.username or "نامشخص",
            first_name=message.from_user.first_name or "کاربر"
        )
        user_manager.update_user(user_id, {'referral_code': referral_code})
        
        # Check if user was referred
        args = message.text.split()
        if len(args) > 1:
            referral_code_param = args[1]
            # Numeric referral code support: user id directly
            if referral_code_param.isdigit():
                referrer_id = int(referral_code_param)
                if referrer_id != user_id and user_manager.user_exists(referrer_id):
                    referral_manager.add_referral(referrer_id, user_id)
                    referrals = referral_manager.get_referrals(referrer_id)
                    user_manager.update_user(referrer_id, {'referrals_count': len(referrals)})
                    reward_coins = 0
                    if len(referrals) % REFERRAL_THRESHOLD == 0:
                        user_manager.add_coin(referrer_id, REFERRAL_REWARD_COINS)
                        reward_coins = REFERRAL_REWARD_COINS
                    await _notify_referrer_new_member(
                        message.bot,
                        referrer_id,
                        user_id,
                        message.from_user.username or "",
                        len(referrals),
                        reward_coins,
                    )
            else:
                # Backward compatibility for old referral codes
                all_users = user_manager.get_all_users()
                for user in all_users:
                    if user.get('referral_code') == referral_code_param and user['id'] != user_id:
                        referrer_id = user['id']
                        referral_manager.add_referral(referrer_id, user_id)
                        referrals = referral_manager.get_referrals(referrer_id)
                        user_manager.update_user(referrer_id, {'referrals_count': len(referrals)})
                        reward_coins = 0
                        if len(referrals) % REFERRAL_THRESHOLD == 0:
                            user_manager.add_coin(referrer_id, REFERRAL_REWARD_COINS)
                            reward_coins = REFERRAL_REWARD_COINS
                        await _notify_referrer_new_member(
                            message.bot,
                            referrer_id,
                            user_id,
                            message.from_user.username or "",
                            len(referrals),
                            reward_coins,
                        )
                        break
    else:
        # Ensure existing users always have numeric referral code
        existing = user_manager.get_user(user_id)
        if existing and existing.get('referral_code') != str(user_id):
            user_manager.update_user(user_id, {'referral_code': str(user_id)})
    
    welcome_text = _render_welcome_text(message.from_user.first_name or "کاربر")
    custom_buttons = ui_settings_manager.get_welcome_buttons()
    if custom_buttons:
        await send_or_edit_with_raw_keyboard(
            chat_id=message.chat.id,
            text=welcome_text,
            reply_markup={'inline_keyboard': custom_buttons},
        )
    else:
        await send_or_edit_with_raw_keyboard(
            chat_id=message.chat.id,
            text=welcome_text,
            reply_markup=AdvancedKeyboard.main_menu_payload(),
        )


@router.callback_query(F.data == "check_force_join")
async def check_force_join(callback: CallbackQuery):
    """Re-check mandatory join and show main menu if completed."""
    ok, missing = await _check_force_join(callback.bot, callback.from_user.id)
    if not ok:
        await _send_force_join_prompt_callback(callback, missing)
        await callback.answer("هنوز عضویت کامل نشده", show_alert=True)
        return

    welcome_text = _render_welcome_text(callback.from_user.first_name or "کاربر")
    custom_buttons = ui_settings_manager.get_welcome_buttons()
    if custom_buttons:
        await send_or_edit_with_raw_keyboard(
            chat_id=callback.message.chat.id,
            message_id=callback.message.message_id,
            text=welcome_text,
            reply_markup={'inline_keyboard': custom_buttons},
        )
    else:
        await send_or_edit_with_raw_keyboard(
            chat_id=callback.message.chat.id,
            message_id=callback.message.message_id,
            text=welcome_text,
            reply_markup=AdvancedKeyboard.main_menu_payload(),
        )
    await callback.answer("عضویت تایید شد")


@router.callback_query(F.data == "shop")
async def shop_menu(callback: CallbackQuery):
    """Show shop menu"""
    if not await _ensure_join_for_callback(callback):
        return
    await send_or_edit_with_raw_keyboard(
        chat_id=callback.message.chat.id,
        message_id=callback.message.message_id,
        text=MessageTemplates.shop_menu(),
        reply_markup=AdvancedKeyboard.shop_menu_payload(),
    )
    await callback.answer()


@router.callback_query(F.data == "buy_plan")
async def buy_plan(callback: CallbackQuery):
    """Show plans for purchase"""
    if not await _ensure_join_for_callback(callback):
        return
    plans = plans_manager.get_all_plans()
    reply_markup = InlineKeyboardMarkup(inline_keyboard=[])
    
    for plan in plans:
        button = InlineKeyboardButton(
            text=f"خریداری {plan['name']} - {plan['price_toman']:,} تومان",
            callback_data=f"select_plan_{plan['id']}"
        )
        reply_markup.inline_keyboard.append([button])
    
    # Add back button
    back_button = InlineKeyboardButton(text="🔙 بازگشت", callback_data="back_shop")
    reply_markup.inline_keyboard.append([back_button])
    
    await callback.message.edit_text(
        MessageTemplates.plans_list(plans),
        reply_markup=reply_markup,
        parse_mode="HTML"
    )
    await callback.answer()


@router.callback_query(F.data.startswith("select_plan_"))
async def select_plan(callback: CallbackQuery):
    """Select plan and choose payment method"""
    plan_id = callback.data.split("_")[-1]
    plan = plans_manager.get_plan(plan_id)
    
    if not plan:
        await callback.answer("❌ پلن یافت نشد", show_alert=True)
        return
    
    # Save plan selection in user session (in production, use proper session management)
    store_plan_info = f"""
    ✅ <b>پلن انتخاب‌شده:</b>
    
    📝 نام: {plan['name']}
    📦 حجم: {plan['volume_gb']} GB
    ⏱️ مدت: {plan['duration_days']} روز
    
    <b>روش پرداخت را انتخاب کنید:</b>
    """
    
    payment_kb = InlineKeyboardMarkup(
        inline_keyboard=[
            [InlineKeyboardButton(text="👛 پرداخت از کیف پول", callback_data=f"pay_wallet_{plan_id}")],
            [InlineKeyboardButton(text="💵 تومان (درگاه)", callback_data=f"pay_toman_{plan_id}")],
            [
                InlineKeyboardButton(text="₮ تتر (USDT)", callback_data=f"pay_usdt_{plan_id}"),
                InlineKeyboardButton(text="◆ ترون (TRX)", callback_data=f"pay_trx_{plan_id}"),
            ],
            [InlineKeyboardButton(text="🔙 بازگشت", callback_data="back_shop")],
        ]
    )

    await callback.message.edit_text(
        store_plan_info,
        reply_markup=payment_kb,
        parse_mode="HTML"
    )
    await callback.answer()


@router.callback_query(F.data == "wallet")
async def wallet_info(callback: CallbackQuery):
    """Show wallet information"""
    if not await _ensure_join_for_callback(callback):
        return
    user = user_manager.get_user(callback.from_user.id)
    if user:
        wallet_text = MessageTemplates.wallet_info(
            user['balance_coin'],
            user['balance_toman']
        )
        
        back_kb = InlineKeyboardMarkup(
            inline_keyboard=[[InlineKeyboardButton(text="🔙 بازگشت", callback_data="back_main")]]
        )
        await callback.message.edit_text(
            wallet_text,
            reply_markup=back_kb,
            parse_mode="HTML"
        )
    await callback.answer()


@router.callback_query(F.data == "referral")
async def referral_info(callback: CallbackQuery):
    """Show referral information"""
    if not await _ensure_join_for_callback(callback):
        return
    user = user_manager.get_user(callback.from_user.id)
    if user:
        bot_info = await callback.bot.get_me()
        bot_username = bot_info.username
        referral_code = str(user['id'])
        if user.get('referral_code') != referral_code:
            user_manager.update_user(callback.from_user.id, {'referral_code': referral_code})

        referrals_count = user.get('referrals_count', 0)
        needed = REFERRAL_THRESHOLD
        referral_text = MessageTemplates.referral_info(
            referral_code,
            referrals_count,
            f"https://t.me/{bot_username}?start={referral_code}"
        )

        # Requested exact warning text with animated premium emoji tag.
        referral_text += (
            "\n\n" + MessageTemplates.warning_margin() +
            f"\n\n🎁 <b>سرور رایگان رفرال:</b> هر {needed} دعوت = 1 کانفیگ رایگان"
        )

        raw_markup = AdvancedKeyboard.referral_free_server_payload(referrals_count, needed)
        await send_or_edit_with_raw_keyboard(
            chat_id=callback.message.chat.id,
            message_id=callback.message.message_id,
            text=referral_text,
            reply_markup=raw_markup,
        )
    await callback.answer()


@router.callback_query(F.data == "free_menu")
async def free_menu(callback: CallbackQuery):
    """Free rewards menu based on referral points."""
    if not await _ensure_join_for_callback(callback):
        return
    user = user_manager.get_user(callback.from_user.id)
    if not user:
        await callback.answer("کاربر یافت نشد", show_alert=True)
        return

    points = _get_points(user)
    can_claim = points >= FREE_REWARD_POINTS_REQUIRED or user.get('balance_coin', 0) >= REFERRAL_REWARD_COINS
    text = (
        "🎁 <b>بخش رایگان</b>\n\n"
        f"امتیاز شما: <code>{points}</code>\n"
        f"هر نفر رفرال: <code>{REFERRAL_POINT_PER_USER}</code> امتیاز\n"
        f"حداقل لازم: <code>{FREE_REWARD_POINTS_REQUIRED}</code> امتیاز\n\n"
        "یا اگر <code>500</code> سکه رفرال داشته باشید می‌تونید کانفیگ رایگان بگیرید."
    )
    payload = AdvancedKeyboard.free_rewards_payload(can_claim)
    await send_or_edit_with_raw_keyboard(
        chat_id=callback.message.chat.id,
        message_id=callback.message.message_id,
        text=text,
        reply_markup=payload,
    )
    await callback.answer()


@router.callback_query(F.data == "claim_free_config_by_points")
async def claim_free_config_by_points(callback: CallbackQuery):
    """Claim free config with referral points."""
    user_id = callback.from_user.id
    user = user_manager.get_user(user_id)
    if not user:
        await callback.answer("کاربر یافت نشد", show_alert=True)
        return

    points = _get_points(user)
    use_points = points >= FREE_REWARD_POINTS_REQUIRED
    use_coins = user.get('balance_coin', 0) >= REFERRAL_REWARD_COINS
    if not use_points and not use_coins:
        await callback.answer("امتیاز یا سکه کافی نیست", show_alert=True)
        return

    if order_manager.user_has_pending(user_id, 'free_points'):
        await callback.answer("یک سفارش رایگان در انتظار دارید", show_alert=True)
        return

    updates = {}
    if use_points:
        spent = float(user.get('referral_points_spent', 0.0)) + FREE_REWARD_POINTS_REQUIRED
        updates['referral_points_spent'] = spent
        consumed_amount = FREE_REWARD_POINTS_REQUIRED
        consumed_currency = 'points'
    else:
        user_manager.deduct_coin(user_id, REFERRAL_REWARD_COINS)
        consumed_amount = REFERRAL_REWARD_COINS
        consumed_currency = 'coin'
    if updates:
        user_manager.update_user(user_id, updates)
    order = order_manager.create_order(
        user_id=user_id,
        order_type='free_points',
        amount=consumed_amount,
        currency=consumed_currency,
        note='Free config by points - admin should send filter/config link',
    )

    await callback.message.edit_text(
        "✅ <b>درخواست کانفیگ رایگان ثبت شد</b>\n\n"
        f"شماره سفارش: <code>{order['id']}</code>\n"
        "ادمین لینک کانفیگ/فیلتر را برای شما ارسال می‌کند.",
        reply_markup=InlineKeyboardMarkup(
            inline_keyboard=[[InlineKeyboardButton(text="🔙 بازگشت", callback_data="back_main")]]
        ),
        parse_mode="HTML",
    )
    try:
        default_tpl = (
            f'<tg-emoji emoji-id="{EMOJI_FIRE}">🔥</tg-emoji> <b>سفارش رایگان جدید</b>\n\n'
            '👤 آیدی عددی: <code>{user_id}</code>\n'
            '📦 شماره سفارش: <code>{order_id}</code>\n'
            '🧾 مصرف‌شده: <code>{amount} {currency}</code>\n'
            '🧩 نوع سفارش: <code>{order_type}</code>\n\n'
            f'<tg-emoji emoji-id="{EMOJI_GIFT}">🎁</tg-emoji> برای تکمیل: پنل ادمین ← مدیریت سفارشات'
        )
        template = ui_settings_manager.get_text_template('admin_order_free', default_tpl)
        ctx = {
            'user_id': user_id,
            'order_id': order['id'],
            'amount': consumed_amount,
            'currency': consumed_currency,
            'order_type': 'free_points',
        }
        text = template
        for k, v in ctx.items():
            text = text.replace(f"{{{k}}}", html.escape(str(v)))
        await callback.bot.send_message(
            ADMIN_ID,
            text,
            parse_mode='HTML',
        )
    except Exception:
        pass
    await callback.answer("کانفیگ رایگان ثبت شد", show_alert=True)


@router.callback_query(F.data == "claim_free_coins_by_points")
async def claim_free_coins_by_points(callback: CallbackQuery):
    """Claim free coins with referral points."""
    user_id = callback.from_user.id
    user = user_manager.get_user(user_id)
    if not user:
        await callback.answer("کاربر یافت نشد", show_alert=True)
        return

    points = _get_points(user)
    if points < FREE_REWARD_POINTS_REQUIRED:
        await callback.answer("امتیاز شما کافی نیست", show_alert=True)
        return

    spent = float(user.get('referral_points_spent', 0.0)) + FREE_REWARD_POINTS_REQUIRED
    user_manager.update_user(user_id, {'referral_points_spent': spent})
    user_manager.add_coin(user_id, FREE_REWARD_COINS)

    await callback.message.edit_text(
        f"✅ <b>{FREE_REWARD_COINS} سکه رایگان به کیف پول شما اضافه شد</b>",
        reply_markup=InlineKeyboardMarkup(
            inline_keyboard=[[InlineKeyboardButton(text="🔙 بازگشت", callback_data="back_main")]]
        ),
        parse_mode="HTML",
    )
    await callback.answer("سکه رایگان دریافت شد", show_alert=True)


@router.callback_query(F.data == "claim_free_server")
async def claim_free_server(callback: CallbackQuery):
    """Claim free server if referral threshold is reached."""
    user_id = callback.from_user.id
    user = user_manager.get_user(user_id)
    if not user:
        await callback.answer("کاربر یافت نشد", show_alert=True)
        return

    referrals_count = user.get('referrals_count', 0)
    if referrals_count < REFERRAL_THRESHOLD:
        remaining = REFERRAL_THRESHOLD - referrals_count
        await callback.answer(f"هنوز {remaining} دعوت دیگر نیاز دارید", show_alert=True)
        return

    if order_manager.user_has_pending(user_id, 'free_referral'):
        await callback.answer("یک سفارش رایگان در انتظار دارید", show_alert=True)
        return

    user_manager.update_user(
        user_id,
        {
            'referrals_count': referrals_count - REFERRAL_THRESHOLD,
        },
    )

    order = order_manager.create_order(
        user_id=user_id,
        order_type='free_referral',
        amount=0,
        currency='referral',
        note='Free config by referral - admin should send filter/config link',
    )

    text = (
        "✅ <b>درخواست سرور رایگان ثبت شد</b>\n\n"
        f"شماره سفارش: <code>{order['id']}</code>\n"
        "ادمین لینک کانفیگ/فیلتر را برای شما ارسال می‌کند."
    )
    kb = InlineKeyboardMarkup(
        inline_keyboard=[[InlineKeyboardButton(text="🔙 بازگشت", callback_data="back_main")]]
    )
    await callback.message.edit_text(text, reply_markup=kb, parse_mode="HTML")
    try:
        await callback.bot.send_message(
            ADMIN_ID,
            "🆕 <b>سفارش رایگان (رفرال) جدید</b>\n\n"
            f"شماره سفارش: <code>{order['id']}</code>\n"
            f"آیدی کاربر: <code>{user_id}</code>",
            parse_mode='HTML',
        )
    except Exception:
        pass
    await callback.answer("با موفقیت دریافت شد", show_alert=True)


@router.callback_query(F.data == "redeem_coins")
async def redeem_coins(callback: CallbackQuery):
    """Redeem coins for free config"""
    user = user_manager.get_user(callback.from_user.id)
    if user:
        text = f"""
        🪙 <b>تبدیل سکه به کانفیگ رایگان</b>
        
        موجودی شما: <code>{user['balance_coin']} سکه</code>
        نیاز: <code>1000 سکه</code>
        
        {'✅ می‌توانید تبدیل کنید' if user['balance_coin'] >= 1000 else '❌ سکه کافی ندارید'}
        """
        
        kb = InlineKeyboardMarkup(inline_keyboard=[])
        if user['balance_coin'] >= 1000:
            kb.inline_keyboard.append([InlineKeyboardButton(text="✅ تبدیل کن", callback_data="confirm_redeem")])
        kb.inline_keyboard.append([InlineKeyboardButton(text="🔙 بازگشت", callback_data="back_shop")])
        
        await callback.message.edit_text(text, reply_markup=kb, parse_mode="HTML")
    await callback.answer()


@router.callback_query(F.data == "back_main")
async def back_to_main(callback: CallbackQuery):
    """Go back to main menu"""
    welcome_text = _render_welcome_text(callback.from_user.first_name or "کاربر")
    custom_buttons = ui_settings_manager.get_welcome_buttons()
    if custom_buttons:
        await send_or_edit_with_raw_keyboard(
            chat_id=callback.message.chat.id,
            message_id=callback.message.message_id,
            text=welcome_text,
            reply_markup={'inline_keyboard': custom_buttons},
        )
    else:
        await send_or_edit_with_raw_keyboard(
            chat_id=callback.message.chat.id,
            message_id=callback.message.message_id,
            text=welcome_text,
            reply_markup=AdvancedKeyboard.main_menu_payload(),
        )
    await callback.answer()


@router.callback_query(F.data == "back_shop")
async def back_to_shop(callback: CallbackQuery):
    """Go back to shop menu"""
    await send_or_edit_with_raw_keyboard(
        chat_id=callback.message.chat.id,
        message_id=callback.message.message_id,
        text=MessageTemplates.shop_menu(),
        reply_markup=AdvancedKeyboard.shop_menu_payload(),
    )
    await callback.answer()


@router.callback_query(F.data == "settings")
async def settings(callback: CallbackQuery):
    """Show settings"""
    text = """
    ⚙️ <b>تنظیمات</b>
    
    🔧 تنظیمات موجود:
    • زبان: فارسی
    • اطلاع‌رسانی: فعال
    • حالت تیره: خودکار
    """
    kb = InlineKeyboardMarkup(inline_keyboard=[[InlineKeyboardButton(text="🔙 بازگشت", callback_data="back_main")]])
    await callback.message.edit_text(text, reply_markup=kb, parse_mode="HTML")
    await callback.answer()


@router.callback_query(F.data == "stats")
async def user_stats(callback: CallbackQuery):
    """Show user statistics"""
    user = user_manager.get_user(callback.from_user.id)
    if user:
        text = f"""
        📊 <b>آمار شما</b>
        
        👤 نام: {user['first_name']}
        📦 کل خریداری: {user['configs_purchased']} پلن
        👥 دعوت‌های موفق: {user['referrals_count']}
        🪙 سکه‌های جمع‌آوری‌شده: {user['balance_coin']}
        💵 موجودی تومان: {user['balance_toman']:,}
        """
        kb = InlineKeyboardMarkup(inline_keyboard=[[InlineKeyboardButton(text="🔙 بازگشت", callback_data="back_main")]])
        await callback.message.edit_text(text, reply_markup=kb, parse_mode="HTML")
    await callback.answer()