remnawave-bedolaga-telegram-bot/app/handlers/balance/main.py

import html
import logging
from aiogram import Dispatcher, types, F
from aiogram.exceptions import TelegramBadRequest
from aiogram.fsm.context import FSMContext
from aiogram.types import InaccessibleMessage
from sqlalchemy.ext.asyncio import AsyncSession

from app.config import settings
from app.states import BalanceStates
from app.database.crud.user import add_user_balance
from app.utils.price_display import calculate_user_price, format_price_button
from app.utils.pricing_utils import format_period_description
from app.database.crud.transaction import (
    get_user_transactions, get_user_transactions_count,
    create_transaction
)
from app.database.models import User, TransactionType, PaymentMethod
from app.keyboards.inline import (
    get_balance_keyboard, get_payment_methods_keyboard,
    get_back_keyboard, get_pagination_keyboard
)
from app.localization.texts import get_texts
from app.services.payment_service import PaymentService
from app.utils.pagination import paginate_list
from app.utils.decorators import error_handler

logger = logging.getLogger(__name__)

TRANSACTIONS_PER_PAGE = 10


async def route_payment_by_method(
    message: types.Message,
    db_user: User,
    amount_kopeks: int,
    state: FSMContext,
    payment_method: str
) -> bool:
    """
    Роутер платежей по методу оплаты.

    Args:
        message: Сообщение для ответа
        db_user: Пользователь БД
        amount_kopeks: Сумма в копейках
        state: FSM состояние
        payment_method: Метод оплаты (yookassa, stars, cryptobot и т.д.)

    Returns:
        True если платеж обработан, False если метод неизвестен
    """
    if payment_method == "stars":
        from .stars import process_stars_payment_amount
        await process_stars_payment_amount(message, db_user, amount_kopeks, state)
        return True

    # Все остальные методы требуют сессию БД
    from app.database.database import AsyncSessionLocal

    if payment_method == "yookassa":
        from .yookassa import process_yookassa_payment_amount
        async with AsyncSessionLocal() as db:
            await process_yookassa_payment_amount(message, db_user, db, amount_kopeks, state)
        return True

    if payment_method == "yookassa_sbp":
        from .yookassa import process_yookassa_sbp_payment_amount
        async with AsyncSessionLocal() as db:
            await process_yookassa_sbp_payment_amount(message, db_user, db, amount_kopeks, state)
        return True

    if payment_method == "mulenpay":
        from .mulenpay import process_mulenpay_payment_amount
        async with AsyncSessionLocal() as db:
            await process_mulenpay_payment_amount(message, db_user, db, amount_kopeks, state)
        return True

    if payment_method == "platega":
        from .platega import process_platega_payment_amount
        async with AsyncSessionLocal() as db:
            await process_platega_payment_amount(message, db_user, db, amount_kopeks, state)
        return True

    if payment_method == "wata":
        from .wata import process_wata_payment_amount
        async with AsyncSessionLocal() as db:
            await process_wata_payment_amount(message, db_user, db, amount_kopeks, state)
        return True

    if payment_method == "pal24":
        from .pal24 import process_pal24_payment_amount
        async with AsyncSessionLocal() as db:
            await process_pal24_payment_amount(message, db_user, db, amount_kopeks, state)
        return True

    if payment_method == "cryptobot":
        from .cryptobot import process_cryptobot_payment_amount
        async with AsyncSessionLocal() as db:
            await process_cryptobot_payment_amount(message, db_user, db, amount_kopeks, state)
        return True

    if payment_method == "heleket":
        from .heleket import process_heleket_payment_amount
        async with AsyncSessionLocal() as db:
            await process_heleket_payment_amount(message, db_user, db, amount_kopeks, state)
        return True

    if payment_method == "cloudpayments":
        from .cloudpayments import process_cloudpayments_payment_amount
        async with AsyncSessionLocal() as db:
            await process_cloudpayments_payment_amount(message, db_user, db, amount_kopeks, state)
        return True

    if payment_method == "freekassa":
        from .freekassa import process_freekassa_payment_amount
        async with AsyncSessionLocal() as db:
            await process_freekassa_payment_amount(message, db_user, db, amount_kopeks, state)
        return True

    return False


async def get_quick_amount_buttons(language: str, user: User) -> list:
    """
    Generate quick amount buttons with user-specific pricing and discounts.

    Args:
        language: User's language for formatting
        user: User object to calculate personalized discounts

    Returns:
        List of button rows for inline keyboard
    """
    if not settings.is_quick_amount_buttons_enabled():
        return []

    from app.localization.texts import get_texts
    from app.config import PERIOD_PRICES
    texts = get_texts(language)

    # В режиме тарифов получаем цены из тарифа пользователя
    tariff_prices = None
    tariff_periods = None
    if settings.is_tariffs_mode():
        from app.database.database import AsyncSessionLocal
        from app.database.crud.subscription import get_subscription_by_user_id
        from app.database.crud.tariff import get_tariff_by_id

        async with AsyncSessionLocal() as db:
            subscription = await get_subscription_by_user_id(db, user.id)
            if subscription and subscription.tariff_id:
                tariff = await get_tariff_by_id(db, subscription.tariff_id)
                if tariff and tariff.period_prices:
                    tariff_prices = {int(k): v for k, v in tariff.period_prices.items()}
                    tariff_periods = sorted(tariff_prices.keys())

    buttons = []

    # Используем периоды тарифа в режиме тарифов, иначе стандартные
    if tariff_periods:
        periods = tariff_periods[:6]
    else:
        periods = settings.get_available_subscription_periods()[:6]

    for period in periods:
        # Получаем цену из тарифа или из PERIOD_PRICES
        if tariff_prices and period in tariff_prices:
            base_price_kopeks = tariff_prices[period]
        else:
            base_price_kopeks = PERIOD_PRICES.get(period, 0)

        if base_price_kopeks > 0:
            # Calculate price with user's promo group discount using unified system
            price_info = calculate_user_price(user, base_price_kopeks, period, "period")

            callback_data = f"quick_amount_{price_info.final_price}"

            # Format button text with discount display
            period_label = f"{period} дней"

            # For balance buttons, use simpler format without emoji and period label prefix
            if price_info.has_discount:
                button_text = (
                    f"{texts.format_price(price_info.base_price)} ➜ "
                    f"{texts.format_price(price_info.final_price)} "
                    f"(-{price_info.discount_percent}%) • {period_label}"
                )
            else:
                button_text = f"{texts.format_price(price_info.final_price)} • {period_label}"

            buttons.append(
                types.InlineKeyboardButton(
                    text=button_text,
                    callback_data=callback_data
                )
            )

    keyboard_rows = []
    for i in range(0, len(buttons), 2):
        keyboard_rows.append(buttons[i:i + 2])

    return keyboard_rows


@error_handler
async def show_balance_menu(
    callback: types.CallbackQuery,
    db_user: User,
    db: AsyncSession
):
    # Проверяем, доступно ли сообщение
    if isinstance(callback.message, InaccessibleMessage):
        await callback.answer()
        return

    texts = get_texts(db_user.language)

    balance_text = texts.BALANCE_INFO.format(
        balance=texts.format_price(db_user.balance_kopeks)
    )

    reply_markup = get_balance_keyboard(db_user.language)

    try:
        if callback.message and callback.message.text:
            await callback.message.edit_text(
                balance_text,
                reply_markup=reply_markup
            )
        elif callback.message and callback.message.caption:
            await callback.message.edit_caption(
                balance_text,
                reply_markup=reply_markup
            )
        else:
            await callback.message.answer(
                balance_text,
                reply_markup=reply_markup
            )
    except TelegramBadRequest as error:
        logger.warning(
            "Failed to edit balance message, sending a new one instead: %s",
            error,
        )
        await callback.message.answer(
            balance_text,
            reply_markup=reply_markup
        )
    await callback.answer()


@error_handler
async def show_balance_history(
    callback: types.CallbackQuery,
    db_user: User,
    db: AsyncSession,
    page: int = 1
):
    texts = get_texts(db_user.language)
    
    offset = (page - 1) * TRANSACTIONS_PER_PAGE
    
    raw_transactions = await get_user_transactions(
        db, db_user.id, 
        limit=TRANSACTIONS_PER_PAGE * 3, 
        offset=offset
    )
    
    seen_transactions = set()
    unique_transactions = []
    
    for transaction in raw_transactions:
        rounded_time = transaction.created_at.replace(second=0, microsecond=0)
        transaction_key = (
            transaction.amount_kopeks,
            transaction.description,
            rounded_time
        )
        
        if transaction_key not in seen_transactions:
            seen_transactions.add(transaction_key)
            unique_transactions.append(transaction)
            
            if len(unique_transactions) >= TRANSACTIONS_PER_PAGE:
                break
    
    all_transactions = await get_user_transactions(db, db_user.id, limit=1000)
    seen_all = set()
    total_unique = 0
    
    for transaction in all_transactions:
        rounded_time = transaction.created_at.replace(second=0, microsecond=0)
        transaction_key = (
            transaction.amount_kopeks,
            transaction.description,
            rounded_time
        )
        if transaction_key not in seen_all:
            seen_all.add(transaction_key)
            total_unique += 1
    
    if not unique_transactions:
        await callback.message.edit_text(
            "📊 История операций пуста",
            reply_markup=get_back_keyboard(db_user.language)
        )
        await callback.answer()
        return
    
    text = "📊 <b>История операций</b>\n\n"
    
    for transaction in unique_transactions:
        emoji = "💰" if transaction.type == TransactionType.DEPOSIT.value else "💸"
        amount_text = f"+{texts.format_price(transaction.amount_kopeks)}" if transaction.type == TransactionType.DEPOSIT.value else f"-{texts.format_price(transaction.amount_kopeks)}"
        
        text += f"{emoji} {amount_text}\n"
        text += f"📝 {transaction.description}\n"
        text += f"📅 {transaction.created_at.strftime('%d.%m.%Y %H:%M')}\n\n"
    
    keyboard = []
    total_pages = (total_unique + TRANSACTIONS_PER_PAGE - 1) // TRANSACTIONS_PER_PAGE
    
    if total_pages > 1:
        pagination_row = get_pagination_keyboard(
            page, total_pages, "balance_history", db_user.language
        )
        keyboard.extend(pagination_row)
    
    keyboard.append([
        types.InlineKeyboardButton(text=texts.BACK, callback_data="menu_balance")
    ])
    
    await callback.message.edit_text(
        text,
        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard),
        parse_mode="HTML"
    )
    await callback.answer()


@error_handler
async def handle_balance_history_pagination(
    callback: types.CallbackQuery,
    db_user: User,
    db: AsyncSession
):
    page = int(callback.data.split('_')[-1])
    await show_balance_history(callback, db_user, db, page)


@error_handler
async def show_payment_methods(
    callback: types.CallbackQuery,
    db_user: User,
    db: AsyncSession,
    state: FSMContext
):
    from app.utils.payment_utils import get_payment_methods_text
    from app.database.crud.subscription import get_subscription_by_user_id
    from app.utils.pricing_utils import calculate_months_from_days, apply_percentage_discount
    from app.config import settings
    from app.services.subscription_service import SubscriptionService

    texts = get_texts(db_user.language)

    # Проверка ограничения на пополнение
    if getattr(db_user, 'restriction_topup', False):
        reason = getattr(db_user, 'restriction_reason', None) or "Действие ограничено администратором"
        support_url = settings.get_support_contact_url()
        keyboard = []
        if support_url:
            keyboard.append([types.InlineKeyboardButton(text="🆘 Обжаловать", url=support_url)])
        keyboard.append([types.InlineKeyboardButton(text=texts.BACK, callback_data="menu_balance")])

        await callback.message.edit_text(
            f"🚫 <b>Пополнение ограничено</b>\n\n{reason}\n\n"
            "Если вы считаете это ошибкой, вы можете обжаловать решение.",
            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
        )
        await callback.answer()
        return

    payment_text = get_payment_methods_text(db_user.language)

    # Добавляем информацию о текущем тарифе пользователя
    subscription = await get_subscription_by_user_id(db, db_user.id)
    tariff_info = ""
    if subscription and not subscription.is_trial:
        # Рассчитываем приблизительную стоимость продления на 30 дней
        duration_days = 30  # Берем для примера 30 дней
        current_traffic = subscription.traffic_limit_gb
        current_connected_squads = subscription.connected_squads or []
        current_device_limit = subscription.device_limit or settings.DEFAULT_DEVICE_LIMIT

        try:
            # Получаем цены для текущих параметров
            from app.config import PERIOD_PRICES
            from app.database.crud.tariff import get_tariff_by_id

            # В режиме тарифов берём цену из тарифа пользователя
            base_price_original = 0
            if settings.is_tariffs_mode() and subscription.tariff_id:
                tariff = await get_tariff_by_id(db, subscription.tariff_id)
                if tariff and tariff.period_prices:
                    base_price_original = tariff.period_prices.get(str(duration_days), 0)

            # Если не нашли в тарифе - используем PERIOD_PRICES
            if base_price_original <= 0:
                base_price_original = PERIOD_PRICES.get(duration_days, 0)

            period_discount_percent = db_user.get_promo_discount("period", duration_days)
            base_price, base_discount_total = apply_percentage_discount(
                base_price_original,
                period_discount_percent,
            )

            # Рассчитываем стоимость серверов
            from app.services.subscription_service import SubscriptionService
            subscription_service = SubscriptionService()
            servers_price_per_month, per_server_monthly_prices = await subscription_service.get_countries_price_by_uuids(
                current_connected_squads,
                db,
                promo_group_id=db_user.promo_group_id,
            )
            servers_discount_percent = db_user.get_promo_discount("servers", duration_days)
            total_servers_price = 0
            for server_price in per_server_monthly_prices:
                discounted_per_month, discount_per_month = apply_percentage_discount(
                    server_price,
                    servers_discount_percent,
                )
                total_servers_price += discounted_per_month

            # Рассчитываем стоимость трафика
            traffic_price_per_month = settings.get_traffic_price(current_traffic)
            traffic_discount_percent = db_user.get_promo_discount("traffic", duration_days)
            traffic_discounted_per_month, traffic_discount_per_month = apply_percentage_discount(
                traffic_price_per_month,
                traffic_discount_percent,
            )

            # Рассчитываем стоимость устройств
            additional_devices = max(0, (current_device_limit or 0) - settings.DEFAULT_DEVICE_LIMIT)
            devices_price_per_month = additional_devices * settings.PRICE_PER_DEVICE
            devices_discount_percent = db_user.get_promo_discount("devices", duration_days)
            devices_discounted_per_month, devices_discount_per_month = apply_percentage_discount(
                devices_price_per_month,
                devices_discount_percent,
            )

            # Общая стоимость
            months_in_period = calculate_months_from_days(duration_days)
            total_price = (
                base_price +
                total_servers_price * months_in_period +
                traffic_discounted_per_month * months_in_period +
                devices_discounted_per_month * months_in_period
            )
            
            traffic_value = current_traffic or 0
            if traffic_value <= 0:
                traffic_display = texts.t("TRAFFIC_UNLIMITED_SHORT", "Безлимит")
            else:
                traffic_display = texts.format_traffic(traffic_value)

            current_tariff_desc = (
                f"📱 Подписка: {len(current_connected_squads)} серверов, "
                f"{traffic_display}, {current_device_limit} устр."
            )
            estimated_price_info = f"💰 Стоимость продления (примерно): {texts.format_price(total_price)} за {duration_days} дней"
            
            tariff_info = f"\n\n📋 <b>Ваш текущий тариф:</b>\n{current_tariff_desc}\n{estimated_price_info}"
        except Exception as e:
            logger.warning(f"Не удалось рассчитать стоимость текущей подписки для пользователя {db_user.id}: {e}")
            tariff_info = ""

    full_text = payment_text + tariff_info

    keyboard = get_payment_methods_keyboard(0, db_user.language)

    # Если сообщение недоступно, отправляем новое
    if isinstance(callback.message, InaccessibleMessage):
        await callback.message.answer(
            full_text,
            reply_markup=keyboard,
            parse_mode="HTML"
        )
        await callback.answer()
        return

    try:
        await callback.message.edit_text(
            full_text,
            reply_markup=keyboard,
            parse_mode="HTML"
        )
    except TelegramBadRequest:
        try:
            await callback.message.edit_caption(
                full_text,
                reply_markup=keyboard,
                parse_mode="HTML"
            )
        except TelegramBadRequest:
            try:
                await callback.message.delete()
            except TelegramBadRequest:
                pass
            await callback.message.answer(
                full_text,
                reply_markup=keyboard,
                parse_mode="HTML"
            )

    await callback.answer()


@error_handler
async def handle_payment_methods_unavailable(
    callback: types.CallbackQuery,
    db_user: User
):
    texts = get_texts(db_user.language)
    
    await callback.answer(
        texts.t(
            "PAYMENT_METHODS_UNAVAILABLE_ALERT",
            "⚠️ В данный момент автоматические способы оплаты временно недоступны. Для пополнения баланса обратитесь в техподдержку.",
        ),
        show_alert=True
    )


@error_handler
async def handle_successful_topup_with_cart(
    user_id: int,
    amount_kopeks: int,
    bot,
    db: AsyncSession
):
    from app.database.crud.user import get_user_by_id
    from aiogram.fsm.context import FSMContext
    from aiogram.fsm.storage.base import StorageKey
    from app.bot import dp
    
    user = await get_user_by_id(db, user_id)
    if not user:
        return
    
    storage = dp.storage
    key = StorageKey(bot_id=bot.id, chat_id=user.telegram_id, user_id=user.telegram_id)
    
    try:
        state_data = await storage.get_data(key)
        current_state = await storage.get_state(key)
        
        if (current_state == "SubscriptionStates:cart_saved_for_topup" and 
            state_data.get('saved_cart')):
            
            texts = get_texts(user.language)
            total_price = state_data.get('total_price', 0)
            
            keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
                [types.InlineKeyboardButton(
                    text="🛒 Вернуться к оформлению подписки", 
                    callback_data="return_to_saved_cart"
                )],
                [types.InlineKeyboardButton(
                    text="💰 Мой баланс", 
                    callback_data="menu_balance"
                )],
                [types.InlineKeyboardButton(
                    text="🏠 Главное меню", 
                    callback_data="back_to_menu"
                )]
            ])
            
            success_text = (
                f"✅ Баланс пополнен на {texts.format_price(amount_kopeks)}!\n\n"
                f"💰 Текущий баланс: {texts.format_price(user.balance_kopeks)}\n\n"
                f"⚠️ <b>Важно:</b> Пополнение баланса не активирует подписку автоматически. "
                f"Обязательно активируйте подписку отдельно!\n\n"
                f"🔄 При наличии сохранённой корзины подписки и включенной автопокупке, "
                f"подписка будет приобретена автоматически после пополнения баланса.\n\n"
                f"🛒 У вас есть сохраненная корзина подписки\n"
                f"Стоимость: {texts.format_price(total_price)}\n\n"
                f"Хотите продолжить оформление?"
            )
            
            await bot.send_message(
                chat_id=user.telegram_id,
                text=success_text,
                reply_markup=keyboard,
                parse_mode="HTML"
            )
            
    except Exception as e:
        logger.error(f"Ошибка обработки успешного пополнения с корзиной: {e}")


@error_handler
async def request_support_topup(
    callback: types.CallbackQuery,
    db_user: User
):
    texts = get_texts(db_user.language)

    if not settings.is_support_topup_enabled():
        await callback.answer(
            texts.t(
                "SUPPORT_TOPUP_DISABLED",
                "Пополнение через поддержку отключено. Попробуйте другой способ оплаты.",
            ),
            show_alert=True,
        )
        return

    support_text = f"""
🛠️ <b>Пополнение через поддержку</b>

Для пополнения баланса обратитесь в техподдержку:
{settings.get_support_contact_display_html()}

Укажите:
• ID: {db_user.telegram_id}
• Сумму пополнения
• Способ оплаты

⏰ Время обработки: 1-24 часа

<b>Доступные способы:</b>
• Криптовалюта
• Переводы между банками
• Другие платежные системы
"""
    
    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
        [types.InlineKeyboardButton(
            text="💬 Написать в поддержку",
            url=settings.get_support_contact_url() or "https://t.me/"
        )],
        [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")]
    ])
    
    await callback.message.edit_text(
        support_text,
        reply_markup=keyboard,
        parse_mode="HTML"
    )
    await callback.answer()


@error_handler
async def process_topup_amount(
    message: types.Message,
    db_user: User,
    state: FSMContext
):
    texts = get_texts(db_user.language)

    try:
        if not message.text:
            if message.successful_payment:
                logger.info(
                    "Получено сообщение об успешном платеже без текста, "
                    "обработчик суммы пополнения завершает работу"
                )
                await state.clear()
                return

            await message.answer(
                texts.INVALID_AMOUNT,
                reply_markup=get_back_keyboard(db_user.language)
            )
            return

        amount_text = message.text.strip()
        if not amount_text:
            await message.answer(
                texts.INVALID_AMOUNT,
                reply_markup=get_back_keyboard(db_user.language)
            )
            return

        amount_rubles = float(amount_text.replace(',', '.'))

        if amount_rubles < 1:
            await message.answer("Минимальная сумма пополнения: 1 ₽")
            return
        
        if amount_rubles > 50000:
            await message.answer("Максимальная сумма пополнения: 50,000 ₽")
            return
        
        amount_kopeks = int(amount_rubles * 100)
        data = await state.get_data()
        payment_method = data.get("payment_method", "stars")
        
        if payment_method in ["yookassa", "yookassa_sbp"]:
            if amount_kopeks < settings.YOOKASSA_MIN_AMOUNT_KOPEKS:
                min_rubles = settings.YOOKASSA_MIN_AMOUNT_KOPEKS / 100
                await message.answer(f"❌ Минимальная сумма для оплаты через YooKassa: {min_rubles:.0f} ₽")
                return
            
            if amount_kopeks > settings.YOOKASSA_MAX_AMOUNT_KOPEKS:
                max_rubles = settings.YOOKASSA_MAX_AMOUNT_KOPEKS / 100
                await message.answer(f"❌ Максимальная сумма для оплаты через YooKassa: {max_rubles:,.0f} ₽".replace(',', ' '))
                return
        
        if not await route_payment_by_method(message, db_user, amount_kopeks, state, payment_method):
            await message.answer("Неизвестный способ оплаты")
        
    except ValueError:
        await message.answer(
            texts.INVALID_AMOUNT,
            reply_markup=get_back_keyboard(db_user.language)
        )


@error_handler
async def handle_sbp_payment(
    callback: types.CallbackQuery,
    db: AsyncSession
):
    try:
        local_payment_id = int(callback.data.split('_')[-1])
        
        from app.database.crud.yookassa import get_yookassa_payment_by_local_id
        payment = await get_yookassa_payment_by_local_id(db, local_payment_id)
        
        if not payment:
            await callback.answer("❌ Платеж не найден", show_alert=True)
            return
        
        import json
        metadata = json.loads(payment.metadata_json) if payment.metadata_json else {}
        confirmation_token = metadata.get("confirmation_token")
        
        if not confirmation_token:
            await callback.answer("❌ Токен подтверждения не найден", show_alert=True)
            return
        
        await callback.message.answer(
            f"Для оплаты через СБП откройте приложение вашего банка и подтвердите платеж.\\n\\n"
            f"Если у вас не открылось банковское приложение автоматически, вы можете:\\n"
            f"1. Скопировать этот токен: <code>{confirmation_token}</code>\\n"
            f"2. Открыть приложение вашего банка\\n"
            f"3. Найти функцию оплаты по токену\\n"
            f"4. Вставить токен и подтвердить платеж",
            parse_mode="HTML"
        )
        
        await callback.answer("Информация об оплате отправлена", show_alert=True)
        
    except Exception as e:
        logger.error(f"Ошибка обработки embedded платежа СБП: {e}")
        await callback.answer("❌ Ошибка обработки платежа", show_alert=True)


@error_handler
async def handle_quick_amount_selection(
    callback: types.CallbackQuery,
    db_user: User,
    state: FSMContext
):
    """
    Обработчик выбора суммы через кнопки быстрого выбора
    """
    # Проверяем, что пользователь в правильном состоянии FSM
    current_state = await state.get_state()
    if current_state != BalanceStates.waiting_for_amount:
        await callback.answer("❌ Сначала выберите способ оплаты", show_alert=True)
        return

    # Извлекаем сумму из callback_data
    try:
        amount_kopeks = int(callback.data.split('_')[-1])

        # Получаем метод оплаты из состояния
        data = await state.get_data()
        payment_method = data.get("payment_method", "yookassa")

        # Роутим платеж на соответствующий обработчик
        if not await route_payment_by_method(
            callback.message, db_user, amount_kopeks, state, payment_method
        ):
            await callback.answer("❌ Неизвестный способ оплаты", show_alert=True)
            return

    except ValueError:
        await callback.answer("❌ Ошибка обработки суммы", show_alert=True)
    except Exception as e:
        logger.error(f"Ошибка обработки быстрого выбора суммы: {e}")
        await callback.answer("❌ Ошибка обработки запроса", show_alert=True)


@error_handler
async def handle_topup_amount_callback(
    callback: types.CallbackQuery,
    db_user: User,
    state: FSMContext,
):
    try:
        _, method, amount_str = callback.data.split("|", 2)
        amount_kopeks = int(amount_str)
    except ValueError:
        await callback.answer("❌ Некорректный запрос", show_alert=True)
        return

    if amount_kopeks <= 0:
        await callback.answer("❌ Некорректная сумма", show_alert=True)
        return

    try:
        # Особые случаи, требующие специальной логики
        if method == "platega":
            from app.database.database import AsyncSessionLocal
            from .platega import process_platega_payment_amount, start_platega_payment

            data = await state.get_data()
            method_code = int(data.get("platega_method", 0)) if data else 0

            if method_code > 0:
                async with AsyncSessionLocal() as db:
                    await process_platega_payment_amount(
                        callback.message, db_user, db, amount_kopeks, state
                    )
            else:
                await state.update_data(platega_pending_amount=amount_kopeks)
                await start_platega_payment(callback, db_user, state)
        elif method == "tribute":
            from .tribute import start_tribute_payment
            await start_tribute_payment(callback, db_user)
            return
        # Стандартные методы через роутер
        elif not await route_payment_by_method(
            callback.message, db_user, amount_kopeks, state, method
        ):
            await callback.answer("❌ Неизвестный способ оплаты", show_alert=True)
            return

        await callback.answer()

    except Exception as error:
        logger.error(f"Ошибка быстрого пополнения: {error}")
        await callback.answer("❌ Ошибка обработки запроса", show_alert=True)


def register_balance_handlers(dp: Dispatcher):
    
    dp.callback_query.register(
        show_balance_menu,
        F.data == "menu_balance"
    )
    
    dp.callback_query.register(
        show_balance_history,
        F.data == "balance_history"
    )
    
    dp.callback_query.register(
        handle_balance_history_pagination,
        F.data.startswith("balance_history_page_")
    )
    
    dp.callback_query.register(
        show_payment_methods,
        F.data == "balance_topup"
    )
    
    from .stars import start_stars_payment
    dp.callback_query.register(
        start_stars_payment,
        F.data == "topup_stars"
    )
    
    from .yookassa import start_yookassa_payment
    dp.callback_query.register(
        start_yookassa_payment,
        F.data == "topup_yookassa"
    )
    
    from .yookassa import start_yookassa_sbp_payment
    dp.callback_query.register(
        start_yookassa_sbp_payment,
        F.data == "topup_yookassa_sbp"
    )

    from .mulenpay import start_mulenpay_payment
    dp.callback_query.register(
        start_mulenpay_payment,
        F.data == "topup_mulenpay"
    )

    from .wata import start_wata_payment
    dp.callback_query.register(
        start_wata_payment,
        F.data == "topup_wata"
    )

    from .pal24 import start_pal24_payment
    dp.callback_query.register(
        start_pal24_payment,
        F.data == "topup_pal24"
    )
    from .pal24 import handle_pal24_method_selection
    dp.callback_query.register(
        handle_pal24_method_selection,
        F.data.startswith("pal24_method_"),
    )

    from .platega import start_platega_payment, handle_platega_method_selection
    dp.callback_query.register(
        start_platega_payment,
        F.data == "topup_platega"
    )
    dp.callback_query.register(
        handle_platega_method_selection,
        F.data.startswith("platega_method_"),
    )

    from .yookassa import check_yookassa_payment_status
    dp.callback_query.register(
        check_yookassa_payment_status,
        F.data.startswith("check_yookassa_")
    )

    from .tribute import start_tribute_payment
    dp.callback_query.register(
        start_tribute_payment,
        F.data == "topup_tribute"
    )
    
    dp.callback_query.register(
        request_support_topup,
        F.data == "topup_support"
    )
    
    from .yookassa import check_yookassa_payment_status
    dp.callback_query.register(
        check_yookassa_payment_status,
        F.data.startswith("check_yookassa_")
    )
    
    dp.message.register(
        process_topup_amount,
        BalanceStates.waiting_for_amount
    )

    from .cryptobot import start_cryptobot_payment
    dp.callback_query.register(
        start_cryptobot_payment,
        F.data == "topup_cryptobot"
    )
    
    from .cryptobot import check_cryptobot_payment_status
    dp.callback_query.register(
        check_cryptobot_payment_status,
        F.data.startswith("check_cryptobot_")
    )

    from .heleket import start_heleket_payment, check_heleket_payment_status
    dp.callback_query.register(
        start_heleket_payment,
        F.data == "topup_heleket"
    )
    dp.callback_query.register(
        check_heleket_payment_status,
        F.data.startswith("check_heleket_")
    )

    from .cloudpayments import start_cloudpayments_payment, handle_cloudpayments_quick_amount
    dp.callback_query.register(
        start_cloudpayments_payment,
        F.data == "topup_cloudpayments"
    )
    dp.callback_query.register(
        handle_cloudpayments_quick_amount,
        F.data.startswith("topup_amount|cloudpayments|")
    )

    from .freekassa import start_freekassa_topup, process_freekassa_quick_amount
    dp.callback_query.register(
        start_freekassa_topup,
        F.data == "topup_freekassa"
    )
    dp.callback_query.register(
        process_freekassa_quick_amount,
        F.data.startswith("topup_amount|freekassa|")
    )

    from .mulenpay import check_mulenpay_payment_status
    dp.callback_query.register(
        check_mulenpay_payment_status,
        F.data.startswith("check_mulenpay_")
    )

    from .wata import check_wata_payment_status
    dp.callback_query.register(
        check_wata_payment_status,
        F.data.startswith("check_wata_")
    )

    from .pal24 import check_pal24_payment_status
    dp.callback_query.register(
        check_pal24_payment_status,
        F.data.startswith("check_pal24_")
    )

    from .platega import check_platega_payment_status
    dp.callback_query.register(
        check_platega_payment_status,
        F.data.startswith("check_platega_")
    )

    dp.callback_query.register(
        handle_payment_methods_unavailable,
        F.data == "payment_methods_unavailable"
    )
    
    # Регистрируем обработчик для кнопок быстрого выбора суммы
    dp.callback_query.register(
        handle_quick_amount_selection,
        F.data.startswith("quick_amount_")
    )

    dp.callback_query.register(
        handle_topup_amount_callback,
        F.data.startswith("topup_amount|")
    )