import logging
import json
import os
import random
from datetime import datetime
from aiogram import Router, F, Bot
from aiogram.types import CallbackQuery, Message, InlineKeyboardMarkup, InlineKeyboardButton
from aiogram.fsm.context import FSMContext
from aiogram.fsm.state import StatesGroup, State
from db import get_user_language, get_language_text, get_button_text, add_user_balance, get_user_balance, data_pool, execute_with_retry, execute_write
import aiohttp
import aiofiles

logger = logging.getLogger(__name__)

router = Router(name="popolnit")

# Состояния для пополнения баланса
class BalanceStates(StatesGroup):
    wait_amount = State()
    wait_payment_method = State()

# Callback данные
BACK_CB = "menu:button9"
BALANCE_WALLET_CB_PREFIX = "balance_wallet:"
BALANCE_BACK_NAV_PREFIX = "balance_back_nav:"

# Загрузка API ключа из crypto_api.json
async def load_cryptobot_token():
    try:
        current_dir = os.path.dirname(os.path.abspath(__file__))
        config_path = os.path.join(current_dir, 'crypto_api.json')
        print(f"Looking for config at: {config_path}")
        
        async with aiofiles.open(config_path, 'r', encoding='utf-8') as f:
            content = await f.read()
            config = json.loads(content)
            token = config.get('cryptobot_token')
            print(f"Token loaded: {token[:10]}..." if token else "Token not found")
            return token
    except Exception as e:
        logger.error(f"Ошибка загрузки crypto_api.json: {e}")
        return None

# Загружаем токен при старте
CRYPTOBOT_TOKEN = None
CRYPTOBOT_API_URL = "https://pay.crypt.bot/api"

async def get_exchange_rates() -> tuple[float, float]:
    """
    Получает актуальные курсы валют из таблицы kurs
    Возвращает кортеж: (USD_TO_RUB, USD_TO_GRN)
    """
    try:
        query = "SELECT rub, grn FROM kurs LIMIT 1"
        result = await execute_with_retry(data_pool, query)
        
        if result and result[0]['rub'] and result[0]['grn']:
            usd_to_rub = float(result[0]['rub'])
            usd_to_grn = float(result[0]['grn'])
            return usd_to_rub, usd_to_grn
        else:
            # Fallback курсы если нет данных в базе
            logger.warning("No exchange rates found in database, using fallback values")
            return 90.0, 40.0
            
    except Exception as e:
        logger.error(f"Error getting exchange rates: {e}")
        # Fallback курсы при ошибке
        return 90.0, 40.0

async def build_back_keyboard(lang: str) -> InlineKeyboardMarkup:
    """Создает клавиатуру с кнопкой назад"""
    button9_text = await get_button_text(lang, "button9", "⬅️ Назад")
    
    return InlineKeyboardMarkup(
        inline_keyboard=[
            [InlineKeyboardButton(text=button9_text, callback_data=BACK_CB)]
        ]
    )

async def build_payment_methods_keyboard(lang: str) -> InlineKeyboardMarkup:
    """Создает клавиатуру с методами оплаты"""
    button13_text = await get_button_text(lang, "button13", "💳 CryptoBot")
    button14_text = await get_button_text(lang, "button14", "💳 Банковская карта")
    button21_text = await get_button_text(lang, "button21", "📞 Оператор")
    back_text = await get_button_text(lang, "button9", "⬅️ Назад")
    
    return InlineKeyboardMarkup(
        inline_keyboard=[
            [InlineKeyboardButton(text=button13_text, callback_data="balance_pay:cryptobot")],
            [InlineKeyboardButton(text=button14_text, callback_data="balance_pay:card")],
            [InlineKeyboardButton(text=button21_text, callback_data="balance_pay:operator")],
            [InlineKeyboardButton(text=back_text, callback_data=BACK_CB)]
        ]
    )

async def get_wallets(lang: str) -> list[tuple[str, list[str]]]:
    """Получает список кошельков с ВСЕМИ их текстами из таблицы wallets"""
    try:
        check_query = """
            SELECT name FROM sqlite_master 
            WHERE type='table' AND name='wallets'
        """
        table_exists = await execute_with_retry(data_pool, check_query)
        
        if not table_exists:
            return []
        
        # ФИЛЬТРУЕМ ПО ЯЗЫКУ ПОЛЬЗОВАТЕЛЯ
        query = "SELECT name, text, text2, text3, text4, text5 FROM wallets WHERE language = ? ORDER BY name"
        result = await execute_with_retry(data_pool, query, (lang,))
        
        wallets = []
        for row in result:
            if row['name']:
                name = str(row['name']).strip()
                # Собираем ВСЕ доступные тексты
                texts = []
                for col in ['text', 'text2', 'text3', 'text4', 'text5']:
                    if row[col] and str(row[col]).strip():
                        texts.append(str(row[col]).strip())
                
                if texts:  # Если есть хотя бы один текст
                    wallets.append((name, texts))
        
        logger.info(f"Found {len(wallets)} wallets for language: {lang}")
        return wallets
        
    except Exception as e:
        logger.error(f"get_wallets error for lang={lang}: {e}")
        return []

async def get_random_wallet_text(wallet_texts: list[str]) -> str:
    """Возвращает случайный текст из списка текстов кошелька"""
    if not wallet_texts:
        return "Текст кошелька не найден"
    
    if len(wallet_texts) == 1:
        return wallet_texts[0]
    
    # Рандомный выбор текста
    return random.choice(wallet_texts)

async def format_wallet_text_for_balance(text: str, user_id: int, amount: float) -> str:
    """
    Форматирует текст кошелька с заменой плейсхолдеров для пополнения баланса
    
    Доступные плейсхолдеры:
    {user_id} - ID пользователя
    {summa} - сумма пополнения в USD
    {summa-rub} - сумма в рублях
    {summa-grn} - сумма в гривнах
    {summa-rub+10%} - сумма в рублях + 10%
    {summa-grn+10%} - сумма в гривнах + 10%
    """
    if not text:
        return text
    
    # Получаем актуальные курсы валют из базы данных
    usd_to_rub, usd_to_grn = await get_exchange_rates()
    
    # Базовая сумма в USD
    base_usd = amount
    
    # Заменяем плейсхолдеры
    formatted_text = text
    
    # {user_id}
    formatted_text = formatted_text.replace('{user_id}', str(user_id))
    
    # {summa} - сумма пополнения в USD
    formatted_text = formatted_text.replace('{summa}', f"{base_usd:.2f}")
    
    # {summa-rub} - сумма в рублях
    summa_rub = base_usd * usd_to_rub
    formatted_text = formatted_text.replace('{summa-rub}', f"{summa_rub:.2f}")
    
    # {summa-grn} - сумма в гривнах
    summa_grn = base_usd * usd_to_grn
    formatted_text = formatted_text.replace('{summa-grn}', f"{summa_grn:.2f}")
    
    # {summa-rub+10%} - сумма в рублях + 10%
    if '{summa-rub+10%}' in formatted_text:
        summa_rub_plus_10 = summa_rub * 1.1
        formatted_text = formatted_text.replace('{summa-rub+10%}', f"{summa_rub_plus_10:.2f}")
    
    # {summa-grn+10%} - сумма в гривнах + 10%
    if '{summa-grn+10%}' in formatted_text:
        summa_grn_plus_10 = summa_grn * 1.1
        formatted_text = formatted_text.replace('{summa-grn+10%}', f"{summa_grn_plus_10:.2f}")
    
    return formatted_text

async def build_wallets_keyboard(lang: str, wallets: list[tuple[str, str]], amount: float) -> InlineKeyboardMarkup:
    """Строит клавиатуру с кошельками для пополнения баланса"""
    rows: list[list[InlineKeyboardButton]] = []
    
    for name, text in wallets:
        rows.append([InlineKeyboardButton(
            text=name,
            callback_data=f"{BALANCE_WALLET_CB_PREFIX}{name}:{amount}"
        )])
    
    # Добавляем кнопку "Назад" - возврат к выбору способа оплаты
    back_to_payment_cb = f"{BALANCE_BACK_NAV_PREFIX}payment:{amount}"
    back_text = await get_button_text(lang, "button9", "⬅️ Назад")
    rows.append([InlineKeyboardButton(text=back_text, callback_data=back_to_payment_cb)])
    
    return InlineKeyboardMarkup(inline_keyboard=rows)

async def build_wallet_text_keyboard(lang: str, amount: float) -> InlineKeyboardMarkup:
    """Строит клавиатуру с кнопкой назад для текста кошелька"""
    # Возврат к списку кошельков
    back_to_wallets_cb = f"{BALANCE_BACK_NAV_PREFIX}wallets:{amount}"
    back_text = await get_button_text(lang, "button9", "⬅️ Назад")
    return InlineKeyboardMarkup(
        inline_keyboard=[[
            InlineKeyboardButton(text=back_text, callback_data=back_to_wallets_cb)
        ]]
    )

async def get_bank_card_texts(city_id: int) -> list[str]:
    """Получает ВСЕ тексты банковской карты для указанного города"""
    try:
        # Используем асинхронный подход
        query = "SELECT * FROM bank_card WHERE city_id LIKE ? LIMIT 1"
        result = await execute_with_retry(data_pool, query, (f'%{city_id}%',))
        
        if not result:
            return []
        
        row = result[0]
        # Собираем все text* колонки
        texts = []
        for key in row.keys():
            if key.startswith('text') and row[key] and str(row[key]).strip():
                texts.append(str(row[key]).strip())
        return texts
    except Exception as e:
        logger.error(f"get_bank_card_texts error for city_id={city_id}: {e}")
        return []

async def get_random_bank_card_text(city_id: int) -> str | None:
    """Возвращает случайный текст банковской карты для города"""
    texts = await get_bank_card_texts(city_id)
    if not texts:
        return None
    return random.choice(texts)

async def format_bank_card_text(text: str, user_id: int, base_price: float) -> str:
    """Форматирует текст банковской карты с заменой плейсхолдеров"""
    if not text:
        return text
    
    # ПОЛУЧАЕМ РЕАЛЬНЫЕ КУРСЫ ИЗ БАЗЫ ДАННЫХ
    USD_TO_RUB, USD_TO_GRN = await get_exchange_rates()
    
    # Базовая сумма в USD
    base_usd = base_price
    
    # Заменяем плейсхолдеры
    formatted_text = text
    
    # {user_id}
    formatted_text = formatted_text.replace('{user_id}', str(user_id))
    
    # {summa-rub} - сумма в рублях
    summa_rub = base_usd * USD_TO_RUB
    formatted_text = formatted_text.replace('{summa-rub}', f"{summa_rub:.2f}")
    
    # {summa-grn} - сумма в гривнах
    summa_grn = base_usd * USD_TO_GRN
    formatted_text = formatted_text.replace('{summa-grn}', f"{summa_grn:.2f}")
    
    # {summa-rub+10%} - сумма в рублях + 10%
    if '{summa-rub+10%}' in formatted_text:
        summa_rub_plus_10 = summa_rub * 1.1
        formatted_text = formatted_text.replace('{summa-rub+10%}', f"{summa_rub_plus_10:.2f}")
    
    # {summa-grn+10%} - сумма в гривнах + 10%
    if '{summa-grn+10%}' in formatted_text:
        summa_grn_plus_10 = summa_grn * 1.1
        formatted_text = formatted_text.replace('{summa-grn+10%}', f"{summa_grn_plus_10:.2f}")
    
    return formatted_text

async def create_balance_invoice(amount: float, description: str = "Пополнение баланса") -> dict:
    """
    Создает инвойс в CryptoBot для пополнения баланса
    """
    global CRYPTOBOT_TOKEN
    
    if not CRYPTOBOT_TOKEN:
        CRYPTOBOT_TOKEN = await load_cryptobot_token()
        
    if not CRYPTOBOT_TOKEN:
        logger.error("CryptoBot token not loaded")
        return None
        
    url = f"{CRYPTOBOT_API_URL}/createInvoice"
    
    headers = {
        "Crypto-Pay-API-Token": CRYPTOBOT_TOKEN,
        "Content-Type": "application/json"
    }
    
    data = {
        "asset": "USDT",
        "amount": str(amount),
        "description": description,
        "paid_btn_name": "viewItem",
        "paid_btn_url": "https://t.me/your_bot",
        "allow_comments": False,
        "allow_anonymous": False,
        "expires_in": 3600
    }
    
    print(f"Creating balance invoice for amount: {amount}")
    
    try:
        async with aiohttp.ClientSession() as session:
            async with session.post(url, headers=headers, json=data) as response:
                result = await response.json()
                print(f"CryptoBot API response: {result}")
                if result.get("ok"):
                    return result.get("result")
                else:
                    logger.error(f"CryptoBot API error: {result}")
                    return None
    except Exception as e:
        logger.error(f"CryptoBot request error: {e}")
        return None

async def check_balance_invoice(invoice_id: int) -> dict:
    """
    Проверяет статус инвойса в CryptoBot для пополнения баланса
    """
    global CRYPTOBOT_TOKEN
    
    if not CRYPTOBOT_TOKEN:
        CRYPTOBOT_TOKEN = await load_cryptobot_token()
        
    if not CRYPTOBOT_TOKEN:
        logger.error("CryptoBot token not loaded")
        return None
        
    url = f"{CRYPTOBOT_API_URL}/getInvoices"
    
    headers = {
        "Crypto-Pay-API-Token": CRYPTOBOT_TOKEN
    }
    
    params = {
        "invoice_ids": str(invoice_id),
        "count": 1
    }
    
    try:
        async with aiohttp.ClientSession() as session:
            async with session.get(url, headers=headers, params=params) as response:
                result = await response.json()
                print(f"Check balance invoice response: {result}")
                if result.get("ok") and result.get("result", {}).get("items"):
                    return result["result"]["items"][0]
                else:
                    return None
    except Exception as e:
        logger.error(f"CryptoBot check invoice error: {e}")
        return None

async def build_balance_payment_keyboard(lang: str, invoice_url: str) -> InlineKeyboardMarkup:
    """
    Создает клавиатуру с кнопками оплаты и проверки для пополнения баланса
    """
    pay_button_text = await get_button_text(lang, "button17", "💳 Оплатить")
    check_button_text = await get_button_text(lang, "button15", "✅ Проверить оплату")
    back_text = await get_button_text(lang, "button9", "⬅️ Назад")
    
    keyboard = InlineKeyboardMarkup(
        inline_keyboard=[
            [InlineKeyboardButton(text=pay_button_text, url=invoice_url)],
            [InlineKeyboardButton(text=check_button_text, callback_data="balance_check_crypto")],
            [InlineKeyboardButton(text=back_text, callback_data=BACK_CB)]
        ]
    )
    
    return keyboard

async def get_referrer_id(user_id: int) -> int | None:
    """
    Получает ID реферера (пригласившего) пользователя
    """
    try:
        query = "SELECT gen_referal_user_id FROM referals WHERE referals_user_id = ?"
        result = await execute_with_retry(data_pool, query, (user_id,))
        if result and result[0]['gen_referal_user_id']:
            return int(result[0]['gen_referal_user_id'])
        return None
    except Exception as e:
        logger.error(f"Error getting referrer for user {user_id}: {e}")
        return None

async def add_referral_bonus(referrer_id: int, amount: float) -> bool:
    """
    Начисляет 10% бонус рефереру от суммы пополнения
    """
    try:
        bonus_amount = amount * 0.10  # 10% от суммы пополнения
        
        # Обновляем баланс реферера
        query = "UPDATE users SET balance = balance + ?, referal_balance = referal_balance + ? WHERE user_id = ?"
        await execute_write(data_pool, query, (bonus_amount, bonus_amount, referrer_id))
        
        logger.info(f"Referral bonus added: user {referrer_id} +{bonus_amount}$ (10% from {amount}$)")
        return True
    except Exception as e:
        logger.error(f"Error adding referral bonus to user {referrer_id}: {e}")
        return False

async def format_text26_with_placeholders(text: str, user_id: int, amount: float) -> str:
    """
    Форматирует текст text26 с заменой плейсхолдеров
    
    Доступные плейсхолдеры:
    {user_id} - ID пользователя
    {summa} - сумма пополнения в USD
    {summa-rub} - сумма в рублях
    {summa-grn} - сумма в гривнах
    {summa-rub+10%} - сумма в рублях + 10%
    {summa-grn+10%} - сумма в гривнах + 10%
    """
    if not text:
        return text
    
    # Получаем актуальные курсы валют из базы данных
    usd_to_rub, usd_to_grn = await get_exchange_rates()
    
    # Базовая сумма в USD
    base_usd = amount
    
    # Заменяем плейсхолдеры
    formatted_text = text
    
    # {user_id}
    formatted_text = formatted_text.replace('{user_id}', str(user_id))
    
    # {summa} - сумма пополнения в USD
    formatted_text = formatted_text.replace('{summa}', f"{base_usd:.2f}")
    
    # {summa-rub} - сумма в рублях
    summa_rub = base_usd * usd_to_rub
    formatted_text = formatted_text.replace('{summa-rub}', f"{summa_rub:.2f}")
    
    # {summa-grn} - сумма в гривнах
    summa_grn = base_usd * usd_to_grn
    formatted_text = formatted_text.replace('{summa-grn}', f"{summa_grn:.2f}")
    
    # {summa-rub+10%} - сумма в рублях + 10%
    if '{summa-rub+10%}' in formatted_text:
        summa_rub_plus_10 = summa_rub * 1.1
        formatted_text = formatted_text.replace('{summa-rub+10%}', f"{summa_rub_plus_10:.2f}")
    
    # {summa-grn+10%} - сумма в гривнах + 10%
    if '{summa-grn+10%}' in formatted_text:
        summa_grn_plus_10 = summa_grn * 1.1
        formatted_text = formatted_text.replace('{summa-grn+10%}', f"{summa_grn_plus_10:.2f}")
    
    return formatted_text

@router.callback_query(F.data == "menu:button8")
async def open_balance_topup(cb: CallbackQuery, state: FSMContext):
    """
    Открывает меню пополнения баланса (button8)
    """
    user_id = cb.from_user.id
    lang = await get_user_language(user_id)
    
    # Получаем текст вопроса из text24
    text24 = await get_language_text(lang, "text24") or "Введите сумму для пополнения баланса (минимум 1$):"
    
    try:
        await cb.message.delete()
    except Exception:
        pass
    
    # Отправляем вопрос с кнопкой назад
    keyboard = await build_back_keyboard(lang)
    await cb.message.answer(text24, reply_markup=keyboard)
    
    # Устанавливаем состояние ожидания суммы
    await state.set_state(BalanceStates.wait_amount)
    await cb.answer()

@router.message(BalanceStates.wait_amount)
async def handle_amount_input(message: Message, state: FSMContext):
    """
    Обрабатывает ввод суммы для пополнения
    """
    user_id = message.from_user.id
    lang = await get_user_language(user_id)
    
    try:
        # Пытаемся преобразовать введенный текст в число
        amount = float(message.text.strip())
        
        # Проверяем минимальную сумму
        if amount < 1:
            error_text = "Минимальная сумма пополнения - 1$"
            keyboard = await build_back_keyboard(lang)
            await message.answer(error_text, reply_markup=keyboard)
            return
            
        # Сохраняем сумму в состоянии
        await state.update_data(amount=amount)
        
        # Получаем текст из text10 (Выберите способ оплаты)
        text10 = await get_language_text(lang, "text10") or "Выберите способ оплаты:"
        
        # Показываем методы оплаты
        keyboard = await build_payment_methods_keyboard(lang)
        await message.answer(text10, reply_markup=keyboard)
        
        # Переходим в состояние выбора метода оплаты
        await state.set_state(BalanceStates.wait_payment_method)
        
    except ValueError:
        # Если введено не число
        error_text = "Пожалуйста, введите число (например: 10.5)"
        keyboard = await build_back_keyboard(lang)
        await message.answer(error_text, reply_markup=keyboard)
    except Exception as e:
        logger.error(f"Error handling amount input: {e}")
        error_text = "Произошла ошибка. Попробуйте снова."
        keyboard = await build_back_keyboard(lang)
        await message.answer(error_text, reply_markup=keyboard)

@router.callback_query(F.data == "balance_pay:cryptobot")
async def handle_balance_cryptobot(cb: CallbackQuery, state: FSMContext):
    """
    Обработчик выбора CryptoBot для пополнения баланса
    """
    user_id = cb.from_user.id
    lang = await get_user_language(user_id)
    
    # Получаем сумму из состояния
    state_data = await state.get_data()
    amount = state_data.get('amount', 0)
    
    if amount <= 0:
        await cb.answer("Ошибка: неверная сумма", show_alert=True)
        return
    
    try:
        await cb.message.delete()
    except Exception:
        pass
    
    # Создаем инвойс для пополнения баланса
    invoice = await create_balance_invoice(
        amount=amount,
        description=f"Пополнение баланса на {amount}$"
    )
    
    if not invoice or not invoice.get('pay_url'):
        error_text = "Ошибка: не удалось создать инвойс для пополнения"
        await cb.message.answer(error_text)
        await cb.answer()
        return
    
    print(f"Balance topup invoice created: {invoice['invoice_id']}, URL: {invoice['pay_url']}")
    
    # Сохраняем ID инвойса и сумму в состоянии для будущей проверки
    await state.update_data(
        balance_invoice_id=invoice['invoice_id'],
        balance_amount=amount
    )
    
    # Формируем текст сообщения
    amount_text = f"Оплатите {amount}$ USDT для пополнения баланса"
    description_text = "Для оплаты нажмите кнопку ниже:"
    
    payment_text = f"{amount_text}\n\n{description_text}"
    
    # Создаем клавиатуру с кнопками
    keyboard = await build_balance_payment_keyboard(lang, invoice['pay_url'])
    
    payment_message = await cb.message.answer(payment_text, reply_markup=keyboard)
    
    # Сохраняем ID сообщения с оплатой для удаления при проверке
    await state.update_data(balance_payment_message_id=payment_message.message_id)
    
    await cb.answer()

@router.callback_query(F.data == "balance_pay:card")
async def handle_balance_card(cb: CallbackQuery, state: FSMContext):
    """
    Обработчик выбора банковской карты для пополнения баланса
    """
    user_id = cb.from_user.id
    lang = await get_user_language(user_id)
    
    # Получаем сумму из состояния
    state_data = await state.get_data()
    amount = state_data.get('amount', 0)
    
    if amount <= 0:
        await cb.answer("Ошибка: неверная сумма", show_alert=True)
        return
    
    try:
        await cb.message.delete()
    except Exception:
        pass
    
    # Получаем текст text26 ПО ЯЗЫКУ ПОЛЬЗОВАТЕЛЯ
    text26_content = await get_language_text(lang, "text26") or "Для пополнения баланса следуйте инструкциям..."
    
    # Форматируем text26 с плейсхолдерами
    formatted_text26 = await format_text26_with_placeholders(text26_content, user_id, amount)
    
    keyboard = await build_back_keyboard(lang)
    await cb.message.answer(formatted_text26, reply_markup=keyboard)
    print(f"Card payment selected for balance topup: user {user_id}, amount: {amount}$, lang: {lang}")
    
    # Очищаем состояние
    await state.clear()
    await cb.answer()

@router.callback_query(F.data == "balance_pay:operator")
async def handle_balance_operator(cb: CallbackQuery, state: FSMContext):
    """
    Обработчик выбора оператора для пополнения баланса
    """
    user_id = cb.from_user.id
    lang = await get_user_language(user_id)
    
    # Получаем сумму из состояния
    state_data = await state.get_data()
    amount = state_data.get('amount', 0)
    
    if amount <= 0:
        await cb.answer("Ошибка: неверная сумма", show_alert=True)
        return
    
    try:
        await cb.message.delete()
    except Exception:
        pass
    
    # Получаем текст text34, если не найден - используем button21
    text34_content = await get_language_text(lang, "text34")
    if not text34_content:
        text34_content = await get_button_text(lang, "button21", "📞 Оператор")
    
    # Получаем кошельки из базы данных ОТФИЛЬТРОВАННЫЕ ПО ЯЗЫКУ
    wallets = await get_wallets(lang)
    
    if wallets:
        # Строим клавиатуру с кошельками
        kb = await build_wallets_keyboard(lang, wallets, amount)
        await cb.message.answer(text34_content, reply_markup=kb)
        print(f"Displayed operator wallets for balance topup: {amount}$")
    else:
        # Если кошельков нет, показываем сообщение об ошибке
        error_text = "Способы оплаты временно недоступны"
        keyboard = await build_back_keyboard(lang)
        await cb.message.answer(error_text, reply_markup=keyboard)
    
    await cb.answer()

@router.callback_query(F.data.startswith(BALANCE_WALLET_CB_PREFIX))
async def on_balance_wallet_clicked(cb: CallbackQuery, state: FSMContext):
    """Обработчик выбора кошелька для пополнения баланса - показывает РАНДОМНЫЙ текст кошелька"""
    user_id = cb.from_user.id
    lang = await get_user_language(user_id)
    
    payload = cb.data[len(BALANCE_WALLET_CB_PREFIX):]
    try:
        wallet_name, amount_str = payload.split(":", 1)
        amount = float(amount_str)
    except Exception:
        await cb.answer("Ошибка выбора кошелька", show_alert=True)
        return
    
    try:
        await cb.message.delete()
    except Exception:
        pass
    
    # Получаем кошельки из базы данных ОТФИЛЬТРОВАННЫЕ ПО ЯЗЫКУ
    wallets = await get_wallets(lang)
    
    # Находим выбранный кошелек и его тексты
    wallet_texts = []
    for name, texts in wallets:  # ← ИЗМЕНЕНО: texts это список
        if name == wallet_name:
            wallet_texts = texts  # ← texts это уже список
            break
    
    if wallet_texts:
        # ВЫБИРАЕМ СЛУЧАЙНЫЙ ТЕКСТ из доступных
        wallet_text = await get_random_wallet_text(wallet_texts)
        
        # ФОРМАТИРУЕМ ТЕКСТ С ПЛЕЙСХОЛДЕРАМИ
        formatted_wallet_text = await format_wallet_text_for_balance(wallet_text, user_id, amount)
        
        # Добавляем заголовок с информацией о пополнении
        header = f"💳 Пополнение баланса\nСумма: {amount}$\n\n"
        full_message = header + formatted_wallet_text
        
        # Создаем клавиатуру с кнопкой "Назад"
        kb = await build_wallet_text_keyboard(lang, amount)
        await cb.message.answer(full_message, reply_markup=kb)
        
        print(f"Displayed RANDOM formatted wallet text for balance topup: {amount}$")
    else:
        error_text = "Информация о кошельке не найдена"
        keyboard = await build_back_keyboard(lang)
        await cb.message.answer(error_text, reply_markup=keyboard)
    
    await cb.answer()

@router.callback_query(F.data.startswith(BALANCE_BACK_NAV_PREFIX))
async def balance_back_navigation_handler(cb: CallbackQuery, state: FSMContext):
    """Обработчик навигации назад для пополнения баланса"""
    user_id = cb.from_user.id
    lang = await get_user_language(user_id)
    
    payload = cb.data[len(BALANCE_BACK_NAV_PREFIX):]
    parts = payload.split(":")
    
    if len(parts) < 2:
        # Если данных недостаточно, возвращаем в главное меню
        keyboard = await build_back_keyboard(lang)
        await cb.message.answer("Возврат в главное меню", reply_markup=keyboard)
        await cb.answer()
        return
    
    nav_type = parts[0]
    amount = float(parts[1])
    
    try:
        await cb.message.delete()
    except Exception:
        pass
    
    # Обновляем состояние для восстановления контекста
    await state.update_data(amount=amount)
    
    if nav_type == "payment":
        # Возврат к выбору способа оплаты
        text10 = await get_language_text(lang, "text10") or "Выберите способ оплаты:"
        kb = await build_payment_methods_keyboard(lang)
        await cb.message.answer(text10, reply_markup=kb)
        
    elif nav_type == "wallets":
        # Возврат к списку кошельков
        text34_content = await get_language_text(lang, "text34") or await get_button_text(lang, "button21", "📞 Оператор")
        
        # Получаем кошельки ОТФИЛЬТРОВАННЫЕ ПО ЯЗЫКУ
        wallets = await get_wallets(lang)
        
        if wallets:
            kb = await build_wallets_keyboard(lang, wallets, amount)
            await cb.message.answer(text34_content, reply_markup=kb)
        else:
            error_text = "Способы оплаты временно недоступны"
            keyboard = await build_back_keyboard(lang)
            await cb.message.answer(error_text, reply_markup=keyboard)
    
    await cb.answer()

@router.callback_query(F.data == "balance_check_crypto")
async def handle_balance_crypto_check(cb: CallbackQuery, state: FSMContext, bot: Bot):
    """
    Обработчик проверки оплаты CryptoBot для пополнения баланса
    """
    user_id = cb.from_user.id
    lang = await get_user_language(user_id)
    
    print(f"=== BALANCE CRYPTO CHECK ===")
    print(f"User: {user_id}")
    
    # Получаем данные из состояния
    state_data = await state.get_data()
    invoice_id = state_data.get('balance_invoice_id')
    amount = state_data.get('balance_amount', 0)
    payment_message_id = state_data.get('balance_payment_message_id')
    
    print(f"Invoice ID: {invoice_id}, Amount: {amount}")
    
    # Удаляем сообщение с оплатой
    try:
        if payment_message_id:
            await bot.delete_message(chat_id=cb.message.chat.id, message_id=payment_message_id)
            print(f"Deleted payment message: {payment_message_id}")
        else:
            await cb.message.delete()
            print("Deleted current message")
    except Exception as e:
        print(f"Error deleting payment message: {e}")
    
    if not invoice_id:
        # Если нет invoice_id в состоянии
        error_text = await get_language_text(lang, "text16") or "Оплата не прошла"
        keyboard = await build_back_keyboard(lang)
        await cb.message.answer(error_text, reply_markup=keyboard)
        print("No invoice ID in state")
        return
    
    # Проверяем статус инвойса
    invoice_data = await check_balance_invoice(invoice_id)
    
    if not invoice_data:
        error_text = await get_language_text(lang, "text16") or "Оплата не прошла"
        keyboard = await build_back_keyboard(lang)
        await cb.message.answer(error_text, reply_markup=keyboard)
        print("Invoice check failed")
        return
    
    status = invoice_data.get('status', 'active')
    print(f"Invoice status: {status}")
    
    if status == 'paid':
        # ПОПОЛНЯЕМ БАЛАНС пользователя
        balance_updated = await add_user_balance(user_id, amount)
        
        if balance_updated:
            # Получаем обновленный баланс
            new_balance = await get_user_balance(user_id)
            
            # Проверяем есть ли у пользователя реферер
            referrer_id = await get_referrer_id(user_id)
            if referrer_id:
                # Начисляем 10% бонус рефереру
                bonus_added = await add_referral_bonus(referrer_id, amount)
                if bonus_added:
                    print(f"Referral bonus added: {referrer_id} got 10% from {amount}$")
                else:
                    print(f"Failed to add referral bonus to {referrer_id}")
            
            # Получаем текст text26 и форматируем его с плейсхолдерами
            text26_content = await get_language_text(lang, "text26") or "Баланс успешно пополнен!"
            
            # Форматируем text26 с плейсхолдерами
            formatted_text26 = await format_text26_with_placeholders(text26_content, user_id, amount)
            
            # Добавляем информацию о балансе
            success_message = f"{formatted_text26}\n\nПополнено: {amount}$\nТекущий баланс: {new_balance}$"
            
            keyboard = await build_back_keyboard(lang)
            await cb.message.answer(success_message, reply_markup=keyboard)
            print(f"Balance topped up via CryptoBot: user {user_id} +{amount}$, new balance: {new_balance}$")
        else:
            error_text = "Ошибка пополнения баланса"
            keyboard = await build_back_keyboard(lang)
            await cb.message.answer(error_text, reply_markup=keyboard)
    else:
        error_text = await get_language_text(lang, "text16") or "Оплата не прошла"
        keyboard = await build_back_keyboard(lang)
        await cb.message.answer(error_text, reply_markup=keyboard)
        print(f"Payment not completed (status: {status})")
    
    # Очищаем состояние после проверки
    await state.clear()
    await cb.answer()