remnawave-bedolaga-telegram-bot/app/keyboards/inline.py

from typing import List, Optional
from aiogram import types
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from datetime import datetime, timezone
from app.database.models import User
from sqlalchemy.ext.asyncio import AsyncSession

from app.config import settings, PERIOD_PRICES, TRAFFIC_PRICES
from app.localization.loader import DEFAULT_LANGUAGE
from app.localization.texts import get_texts
from app.utils.miniapp_buttons import build_miniapp_or_callback_button
from app.utils.pricing_utils import (
    format_period_description,
    apply_percentage_discount,
)
from app.utils.price_display import PriceInfo, format_price_button
from app.utils.subscription_utils import (
    get_display_subscription_link,
    get_happ_cryptolink_redirect_link,
)
import logging

logger = logging.getLogger(__name__)


async def get_main_menu_keyboard_async(
    db: AsyncSession,
    language: str = DEFAULT_LANGUAGE,
    is_admin: bool = False,
    has_had_paid_subscription: bool = False,
    has_active_subscription: bool = False,
    subscription_is_active: bool = False,
    balance_kopeks: int = 0,
    subscription=None,
    show_resume_checkout: bool = False,
    has_saved_cart: bool = False,
    *,
    is_moderator: bool = False,
    custom_buttons: Optional[list[InlineKeyboardButton]] = None,
    user=None,  # Добавляем параметр пользователя для получения данных
) -> InlineKeyboardMarkup:
    """
    Асинхронная версия get_main_menu_keyboard с поддержкой конструктора меню.

    Если MENU_LAYOUT_ENABLED=True, использует конфигурацию из БД.
    Иначе делегирует в синхронную версию.
    """
    if settings.MENU_LAYOUT_ENABLED:
        from app.services.menu_layout_service import MenuLayoutService, MenuContext
        from datetime import datetime

        # Получаем данные для плейсхолдеров
        subscription_days_left = 0
        traffic_used_gb = 0.0
        traffic_left_gb = 0.0
        referral_count = 0
        referral_earnings_kopeks = 0
        registration_days = 0
        promo_group_id = None
        has_autopay = False
        username = ""

        # Заполняем данными из подписки
        if subscription:
            # Дни до окончания подписки
            if hasattr(subscription, 'days_left'):
                # Используем свойство из модели, которое правильно вычисляет дни в UTC
                subscription_days_left = subscription.days_left
            elif hasattr(subscription, 'end_date') and subscription.end_date:
                # Fallback: вычисляем вручную, используя UTC
                now_utc = datetime.now(timezone.utc).replace(tzinfo=None)
                days_left = (subscription.end_date - now_utc).days
                subscription_days_left = max(0, days_left)
            
            # Трафик
            if hasattr(subscription, 'traffic_used_gb'):
                traffic_used_gb = subscription.traffic_used_gb or 0.0
            
            if hasattr(subscription, 'traffic_limit_gb') and subscription.traffic_limit_gb:
                traffic_left_gb = max(0, subscription.traffic_limit_gb - (subscription.traffic_used_gb or 0))
            
            # Автоплатеж
            if hasattr(subscription, 'autopay_enabled'):
                has_autopay = subscription.autopay_enabled

        # Получаем данные пользователя
        if user:
            # Имя пользователя
            if hasattr(user, 'username') and user.username:
                username = user.username
            elif hasattr(user, 'first_name') and user.first_name:
                username = user.first_name
            
            # Дни с регистрации
            if hasattr(user, 'created_at') and user.created_at:
                now_utc = datetime.now(timezone.utc).replace(tzinfo=None)
                registration_days = (now_utc - user.created_at).days
            
            # ID промо-группы
            if hasattr(user, 'promo_group_id'):
                promo_group_id = user.promo_group_id

        # Получаем данные о рефералах из БД (если нужно)
        try:
            from app.database.crud.referral import get_user_referral_stats
            if user and hasattr(user, 'id'):
                referral_data = await get_user_referral_stats(db, user.id)
                if referral_data:
                    referral_count = referral_data.get('invited_count', 0)
                    referral_earnings_kopeks = referral_data.get('total_earned_kopeks', 0)
        except Exception as e:
            logger.error(f"Error getting referral data: {e}")

        context = MenuContext(
            language=language,
            is_admin=is_admin,
            is_moderator=is_moderator,
            has_active_subscription=has_active_subscription,
            subscription_is_active=subscription_is_active,
            has_had_paid_subscription=has_had_paid_subscription,
            balance_kopeks=balance_kopeks,
            subscription=subscription,
            show_resume_checkout=show_resume_checkout,
            has_saved_cart=has_saved_cart,
            custom_buttons=custom_buttons or [],
            # Добавляем данные для плейсхолдеров
            username=username,
            subscription_days=subscription_days_left,
            traffic_used_gb=traffic_used_gb,
            traffic_left_gb=traffic_left_gb,
            referral_count=referral_count,
            referral_earnings_kopeks=referral_earnings_kopeks,
            registration_days=registration_days,
            promo_group_id=promo_group_id,
            has_autopay=has_autopay,
        )

        return await MenuLayoutService.build_keyboard(db, context)

    # Fallback на синхронную версию
    return get_main_menu_keyboard(
        language=language,
        is_admin=is_admin,
        has_had_paid_subscription=has_had_paid_subscription,
        has_active_subscription=has_active_subscription,
        subscription_is_active=subscription_is_active,
        balance_kopeks=balance_kopeks,
        subscription=subscription,
        show_resume_checkout=show_resume_checkout,
        has_saved_cart=has_saved_cart,
        is_moderator=is_moderator,
        custom_buttons=custom_buttons,
    )


def _get_localized_value(values, language: str, default_language: str = "en") -> str:
    if not isinstance(values, dict):
        return ""

    candidates = []
    normalized_language = (language or "").strip().lower()

    if normalized_language:
        candidates.append(normalized_language)
        if "-" in normalized_language:
            candidates.append(normalized_language.split("-")[0])

    default_language = (default_language or "").strip().lower()
    if default_language and default_language not in candidates:
        candidates.append(default_language)

    for candidate in candidates:
        if not candidate:
            continue
        value = values.get(candidate)
        if isinstance(value, str) and value.strip():
            return value

    for value in values.values():
        if isinstance(value, str) and value.strip():
            return value

    return ""


def _build_additional_buttons(additional_section, language: str) -> List[InlineKeyboardButton]:
    if not isinstance(additional_section, dict):
        return []

    buttons = additional_section.get("buttons")
    if not isinstance(buttons, list):
        return []

    localized_buttons: List[InlineKeyboardButton] = []

    for button in buttons:
        if not isinstance(button, dict):
            continue

        button_text = _get_localized_value(button.get("buttonText"), language)
        button_link = button.get("buttonLink")

        if not button_text or not button_link:
            continue

        localized_buttons.append(
            InlineKeyboardButton(text=button_text, url=button_link)
        )

    return localized_buttons


_LANGUAGE_DISPLAY_NAMES = {
    "ru": "🇷🇺 Русский",
    "ru-ru": "🇷🇺 Русский",
    "en": "🇬🇧 English",
    "en-us": "🇺🇸 English",
    "en-gb": "🇬🇧 English",
    "ua": "🇺🇦 Українська",
    "uk": "🇺🇦 Українська",
    "uk-ua": "🇺🇦 Українська",
    "kk": "🇰🇿 Қазақша",
    "kk-kz": "🇰🇿 Қазақша",
    "kz": "🇰🇿 Қазақша",
    "uz": "🇺🇿 Oʻzbekcha",
    "uz-uz": "🇺🇿 Oʻzbekcha",
    "tr": "🇹🇷 Türkçe",
    "tr-tr": "🇹🇷 Türkçe",
    "pl": "🇵🇱 Polski",
    "pl-pl": "🇵🇱 Polski",
    "de": "🇩🇪 Deutsch",
    "de-de": "🇩🇪 Deutsch",
    "fr": "🇫🇷 Français",
    "fr-fr": "🇫🇷 Français",
    "es": "🇪🇸 Español",
    "es-es": "🇪🇸 Español",
    "it": "🇮🇹 Italiano",
    "it-it": "🇮🇹 Italiano",
    "pt": "🇵🇹 Português",
    "pt-pt": "🇵🇹 Português",
    "pt-br": "🇧🇷 Português",
    "zh": "🇨🇳 中文",
    "zh-cn": "🇨🇳 中文 (简体)",
    "zh-hans": "🇨🇳 中文 (简体)",
    "zh-tw": "🇹🇼 中文 (繁體)",
    "zh-hant": "🇹🇼 中文 (繁體)",
    "vi": "🇻🇳 Tiếng Việt",
    "vi-vn": "🇻🇳 Tiếng Việt",
}

def get_rules_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    return InlineKeyboardMarkup(inline_keyboard=[
        [
            InlineKeyboardButton(text=texts.RULES_ACCEPT, callback_data="rules_accept"),
            InlineKeyboardButton(text=texts.RULES_DECLINE, callback_data="rules_decline")
        ]
    ])

def get_privacy_policy_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    return InlineKeyboardMarkup(inline_keyboard=[
        [
            InlineKeyboardButton(
                text=texts.PRIVACY_POLICY_ACCEPT,
                callback_data="privacy_policy_accept"
            ),
            InlineKeyboardButton(
                text=texts.PRIVACY_POLICY_DECLINE,
                callback_data="privacy_policy_decline"
            )
        ]
    ])

def get_channel_sub_keyboard(
    channel_link: Optional[str],
    language: str = DEFAULT_LANGUAGE,
) -> InlineKeyboardMarkup:
    texts = get_texts(language)

    buttons: List[List[InlineKeyboardButton]] = []

    if channel_link:
        buttons.append(
            [
                InlineKeyboardButton(
                    text=texts.t("CHANNEL_SUBSCRIBE_BUTTON", "🔗 Подписаться"),
                    url=channel_link,
                )
            ]
        )

    buttons.append(
        [
            InlineKeyboardButton(
                text=texts.t("CHANNEL_CHECK_BUTTON", "✅ Я подписался"),
                callback_data="sub_channel_check",
            )
        ]
    )

    return InlineKeyboardMarkup(inline_keyboard=buttons)


def get_post_registration_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    return InlineKeyboardMarkup(inline_keyboard=[
        [
            InlineKeyboardButton(
                text=texts.t("POST_REGISTRATION_TRIAL_BUTTON", "🚀 Подключиться бесплатно 🚀"),
                callback_data="trial_activate"
            )
        ],
        [InlineKeyboardButton(text=texts.t("SKIP_BUTTON", "Пропустить ➡️"), callback_data="back_to_menu")],
    ])


def get_language_selection_keyboard(
    current_language: Optional[str] = None,
    *,
    include_back: bool = False,
    language: str = DEFAULT_LANGUAGE,
) -> InlineKeyboardMarkup:
    available_languages = settings.get_available_languages()

    buttons: List[List[InlineKeyboardButton]] = []
    row: List[InlineKeyboardButton] = []

    normalized_current = (current_language or "").lower()

    for index, lang_code in enumerate(available_languages, start=1):
        normalized_code = lang_code.lower()
        display_name = _LANGUAGE_DISPLAY_NAMES.get(
            normalized_code,
            normalized_code.upper(),
        )

        prefix = "✅ " if normalized_code == normalized_current and normalized_current else ""

        row.append(
            InlineKeyboardButton(
                text=f"{prefix}{display_name}",
                callback_data=f"language_select:{normalized_code}",
            )
        )

        if len(row) == 2:
            buttons.append(row)
            row = []

    if row:
        buttons.append(row)

    if include_back:
        texts = get_texts(language)
        buttons.append([InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")])

    return InlineKeyboardMarkup(inline_keyboard=buttons)


def _build_text_main_menu_keyboard(
    language: str,
    texts,
    *,
    is_admin: bool,
    is_moderator: bool,
) -> InlineKeyboardMarkup:
    profile_text = texts.t("MENU_PROFILE", "👤 Личный кабинет")
    miniapp_url = settings.get_main_menu_miniapp_url()

    if miniapp_url:
        profile_button = InlineKeyboardButton(
            text=profile_text,
            web_app=types.WebAppInfo(url=miniapp_url),
        )
    else:
        profile_button = InlineKeyboardButton(
            text=profile_text,
            callback_data="menu_profile_unavailable",
        )

    keyboard_rows: List[List[InlineKeyboardButton]] = [[profile_button]]

    if settings.is_language_selection_enabled():
        keyboard_rows.append([
            InlineKeyboardButton(text=texts.MENU_LANGUAGE, callback_data="menu_language")
        ])

    support_enabled = False
    try:
        from app.services.support_settings_service import SupportSettingsService

        support_enabled = SupportSettingsService.is_support_menu_enabled()
    except Exception:
        support_enabled = settings.SUPPORT_MENU_ENABLED

    if support_enabled:
        keyboard_rows.append([
            InlineKeyboardButton(text=texts.MENU_SUPPORT, callback_data="menu_support")
        ])

    if is_admin:
        keyboard_rows.append([
            InlineKeyboardButton(text=texts.MENU_ADMIN, callback_data="admin_panel")
        ])
    elif is_moderator:
        keyboard_rows.append([
            InlineKeyboardButton(text="🧑‍⚖️ Модерация", callback_data="moderator_panel")
        ])

    return InlineKeyboardMarkup(inline_keyboard=keyboard_rows)


def get_main_menu_keyboard(
    language: str = DEFAULT_LANGUAGE,
    is_admin: bool = False,
    has_had_paid_subscription: bool = False,
    has_active_subscription: bool = False,
    subscription_is_active: bool = False,
    balance_kopeks: int = 0,
    subscription=None,
    show_resume_checkout: bool = False,
    has_saved_cart: bool = False,  # Новый параметр для отображения уведомления о сохраненной корзине
    *,
    is_moderator: bool = False,
    custom_buttons: Optional[list[InlineKeyboardButton]] = None,
) -> InlineKeyboardMarkup:
    texts = get_texts(language)

    if settings.is_text_main_menu_mode():
        return _build_text_main_menu_keyboard(
            language,
            texts,
            is_admin=is_admin,
            is_moderator=is_moderator,
        )
    
    if settings.DEBUG:
        print(f"DEBUG KEYBOARD: language={language}, is_admin={is_admin}, has_had_paid={has_had_paid_subscription}, has_active={has_active_subscription}, sub_active={subscription_is_active}, balance={balance_kopeks}")
    
    safe_balance = balance_kopeks or 0
    if hasattr(texts, 'BALANCE_BUTTON') and safe_balance > 0:
        balance_button_text = texts.BALANCE_BUTTON.format(balance=texts.format_price(safe_balance))
    else:
        balance_button_text = texts.t(
            "BALANCE_BUTTON_DEFAULT",
            "💰 Баланс: {balance}",
        ).format(balance=texts.format_price(safe_balance))
    
    keyboard: list[list[InlineKeyboardButton]] = []
    paired_buttons: list[InlineKeyboardButton] = []

    if has_active_subscription and subscription_is_active:
        connect_mode = settings.CONNECT_BUTTON_MODE
        subscription_link = get_display_subscription_link(subscription)

        def _fallback_connect_button() -> InlineKeyboardButton:
            return InlineKeyboardButton(
                text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
                callback_data="subscription_connect",
            )

        if connect_mode == "miniapp_subscription":
            if subscription_link:
                keyboard.append([
                    InlineKeyboardButton(
                        text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
                        web_app=types.WebAppInfo(url=subscription_link)
                    )
                ])
            else:
                keyboard.append([_fallback_connect_button()])
        elif connect_mode == "miniapp_custom":
            keyboard.append([
                InlineKeyboardButton(
                    text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
                    web_app=types.WebAppInfo(url=settings.MINIAPP_CUSTOM_URL)
                )
            ])
        elif connect_mode == "link":
            if subscription_link:
                keyboard.append([
                    InlineKeyboardButton(
                        text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
                        url=subscription_link
                    )
                ])
            else:
                keyboard.append([_fallback_connect_button()])
        elif connect_mode == "happ_cryptolink":
            if subscription_link:
                keyboard.append([
                    InlineKeyboardButton(
                        text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
                        callback_data="open_subscription_link",
                    )
                ])
            else:
                keyboard.append([_fallback_connect_button()])
        else:
            keyboard.append([_fallback_connect_button()])

        happ_row = get_happ_download_button_row(texts)
        if happ_row:
            keyboard.append(happ_row)
        paired_buttons.append(
            InlineKeyboardButton(text=texts.MENU_SUBSCRIPTION, callback_data="menu_subscription")
        )

        # Добавляем кнопку докупки трафика для лимитированных подписок
        # В режиме тарифов проверяем tariff_id (детальная проверка в хендлере)
        # В классическом режиме проверяем глобальные настройки
        show_traffic_topup = False
        if subscription and not subscription.is_trial and (subscription.traffic_limit_gb or 0) > 0:
            if settings.is_tariffs_mode() and getattr(subscription, 'tariff_id', None):
                # Режим тарифов - показываем кнопку, проверка настроек тарифа в хендлере
                show_traffic_topup = settings.BUY_TRAFFIC_BUTTON_VISIBLE
            elif settings.is_traffic_topup_enabled() and not settings.is_traffic_topup_blocked():
                # Классический режим - проверяем глобальные настройки
                show_traffic_topup = settings.BUY_TRAFFIC_BUTTON_VISIBLE

        if show_traffic_topup:
            paired_buttons.append(
                InlineKeyboardButton(text=texts.t("BUY_TRAFFIC_BUTTON", "📈 Докупить трафик"), callback_data="buy_traffic")
            )

    keyboard.append([InlineKeyboardButton(text=balance_button_text, callback_data="menu_balance")])
    
    show_trial = not has_had_paid_subscription and not has_active_subscription

    show_buy = not has_active_subscription or not subscription_is_active
    current_subscription = subscription
    has_active_paid_subscription = bool(
        current_subscription
        and not getattr(current_subscription, "is_trial", False)
        and getattr(current_subscription, "is_active", False)
    )
    simple_purchase_button = None
    if settings.SIMPLE_SUBSCRIPTION_ENABLED:
        simple_purchase_button = InlineKeyboardButton(
            text=texts.MENU_SIMPLE_SUBSCRIPTION,
            callback_data="simple_subscription_purchase",
        )

    subscription_buttons: list[InlineKeyboardButton] = []

    if show_trial:
        subscription_buttons.append(
            InlineKeyboardButton(text=texts.MENU_TRIAL, callback_data="menu_trial")
        )
    
    if show_buy:
        subscription_buttons.append(
            InlineKeyboardButton(text=texts.MENU_BUY_SUBSCRIPTION, callback_data="menu_buy")
        )
    
    if subscription_buttons:
        paired_buttons.extend(subscription_buttons)
    if simple_purchase_button:
        paired_buttons.append(simple_purchase_button)

    if show_resume_checkout or has_saved_cart:
        resume_callback = (
            "return_to_saved_cart" if has_saved_cart else "subscription_resume_checkout"
        )
        paired_buttons.append(
            InlineKeyboardButton(
                text=texts.RETURN_TO_SUBSCRIPTION_CHECKOUT,
                callback_data=resume_callback,
            )
        )

    if custom_buttons:
        for button in custom_buttons:
            if isinstance(button, InlineKeyboardButton):
                paired_buttons.append(button)

    # Добавляем кнопки промокода и рефералов, учитывая настройки
    paired_buttons.append(
        InlineKeyboardButton(text=texts.MENU_PROMOCODE, callback_data="menu_promocode")
    )
    
    # Добавляем кнопку рефералов, только если программа включена
    if settings.is_referral_program_enabled():
        paired_buttons.append(
            InlineKeyboardButton(text=texts.MENU_REFERRALS, callback_data="menu_referrals")
        )

    # Добавляем кнопку конкурсов
    if settings.CONTESTS_ENABLED and settings.CONTESTS_BUTTON_VISIBLE:
        paired_buttons.append(
            InlineKeyboardButton(text=texts.t("CONTESTS_BUTTON", "🎲 Конкурсы"), callback_data="contests_menu")
        )

    try:
        from app.services.support_settings_service import SupportSettingsService
        support_enabled = SupportSettingsService.is_support_menu_enabled()
    except Exception:
        support_enabled = settings.SUPPORT_MENU_ENABLED

    if support_enabled:
        paired_buttons.append(
            InlineKeyboardButton(text=texts.MENU_SUPPORT, callback_data="menu_support")
        )

    # Добавляем кнопку активации
    if settings.ACTIVATE_BUTTON_VISIBLE:
        paired_buttons.append(
            InlineKeyboardButton(text=settings.ACTIVATE_BUTTON_TEXT, callback_data="activate_button")
        )

    paired_buttons.append(
        InlineKeyboardButton(
            text=texts.t("MENU_INFO", "ℹ️ Инфо"),
            callback_data="menu_info",
        )
    )

    if settings.is_language_selection_enabled():
        paired_buttons.append(
            InlineKeyboardButton(text=texts.MENU_LANGUAGE, callback_data="menu_language")
        )

    for i in range(0, len(paired_buttons), 2):
        row = paired_buttons[i : i + 2]
        keyboard.append(row)

    if settings.DEBUG:
        print(f"DEBUG KEYBOARD: is_admin={is_admin}, добавляем админ кнопку: {is_admin}")

    if is_admin:
        if settings.DEBUG:
            print("DEBUG KEYBOARD: Админ кнопка ДОБАВЛЕНА!")
        keyboard.append([
            InlineKeyboardButton(text=texts.MENU_ADMIN, callback_data="admin_panel")
        ])
    else:
        if settings.DEBUG:
            print("DEBUG KEYBOARD: Админ кнопка НЕ добавлена")
    # Moderator access (limited support panel)
    if (not is_admin) and is_moderator:
        keyboard.append([
            InlineKeyboardButton(text="🧑‍⚖️ Модерация", callback_data="moderator_panel")
        ])
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)


def get_info_menu_keyboard(
    language: str = DEFAULT_LANGUAGE,
    show_privacy_policy: bool = False,
    show_public_offer: bool = False,
    show_faq: bool = False,
    show_promo_groups: bool = False,
) -> InlineKeyboardMarkup:
    texts = get_texts(language)

    buttons: List[List[InlineKeyboardButton]] = []

    if show_faq:
        buttons.append([
            InlineKeyboardButton(
                text=texts.t("MENU_FAQ", "❓ FAQ"),
                callback_data="menu_faq",
            )
        ])

    if show_promo_groups:
        buttons.append([
            InlineKeyboardButton(
                text=texts.t("MENU_PROMO_GROUPS_INFO", "🎯 Промогруппы"),
                callback_data="menu_info_promo_groups",
            )
        ])

    if show_privacy_policy:
        buttons.append([
            InlineKeyboardButton(
                text=texts.t("MENU_PRIVACY_POLICY", "🛡️ Политика конф."),
                callback_data="menu_privacy_policy",
            )
        ])

    if show_public_offer:
        buttons.append([
            InlineKeyboardButton(
                text=texts.t("MENU_PUBLIC_OFFER", "📄 Оферта"),
                callback_data="menu_public_offer",
            )
        ])

    buttons.append([
        InlineKeyboardButton(text=texts.MENU_RULES, callback_data="menu_rules")
    ])

    server_status_mode = settings.get_server_status_mode()
    server_status_text = texts.t("MENU_SERVER_STATUS", "📊 Статус серверов")

    if server_status_mode == "external_link":
        status_url = settings.get_server_status_external_url()
        if status_url:
            buttons.append([InlineKeyboardButton(text=server_status_text, url=status_url)])
    elif server_status_mode == "external_link_miniapp":
        status_url = settings.get_server_status_external_url()
        if status_url:
            buttons.append([
                InlineKeyboardButton(
                    text=server_status_text,
                    web_app=types.WebAppInfo(url=status_url),
                )
            ])
    elif server_status_mode == "xray":
        buttons.append([
            InlineKeyboardButton(
                text=server_status_text,
                callback_data="menu_server_status",
            )
        ])

    buttons.append([InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")])

    return InlineKeyboardMarkup(inline_keyboard=buttons)


def get_happ_download_button_row(texts) -> Optional[List[InlineKeyboardButton]]:
    if not settings.is_happ_download_button_enabled():
        return None

    return [
        InlineKeyboardButton(
            text=texts.t("HAPP_DOWNLOAD_BUTTON", "⬇️ Скачать Happ"),
            callback_data="subscription_happ_download"
        )
    ]


def get_happ_cryptolink_keyboard(
    subscription_link: str,
    language: str = DEFAULT_LANGUAGE,
    redirect_link: Optional[str] = None,
) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    final_redirect_link = redirect_link or get_happ_cryptolink_redirect_link(subscription_link)

    buttons: List[List[InlineKeyboardButton]] = []

    if final_redirect_link:
        buttons.append([
            InlineKeyboardButton(
                text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
                url=final_redirect_link,
            )
        ])

    buttons.extend([
        [
            InlineKeyboardButton(
                text=texts.t("HAPP_PLATFORM_IOS", "🍎 iOS"),
                callback_data="happ_download_ios",
            )
        ],
        [
            InlineKeyboardButton(
                text=texts.t("HAPP_PLATFORM_ANDROID", "🤖 Android"),
                callback_data="happ_download_android",
            )
        ],
        [
            InlineKeyboardButton(
                text=texts.t("HAPP_PLATFORM_MACOS", "🖥️ Mac OS"),
                callback_data="happ_download_macos",
            )
        ],
        [
            InlineKeyboardButton(
                text=texts.t("HAPP_PLATFORM_WINDOWS", "💻 Windows"),
                callback_data="happ_download_windows",
            )
        ],
        [
            InlineKeyboardButton(
                text=texts.t("BACK_TO_MAIN_MENU_BUTTON", "⬅️ В главное меню"),
                callback_data="back_to_menu",
            )
        ],
    ])

    return InlineKeyboardMarkup(inline_keyboard=buttons)


def get_happ_download_platform_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    buttons = [
        [InlineKeyboardButton(text=texts.t("HAPP_PLATFORM_IOS", "🍎 iOS"), callback_data="happ_download_ios")],
        [InlineKeyboardButton(text=texts.t("HAPP_PLATFORM_ANDROID", "🤖 Android"), callback_data="happ_download_android")],
        [InlineKeyboardButton(text=texts.t("HAPP_PLATFORM_MACOS", "🖥️ Mac OS"), callback_data="happ_download_macos")],
        [InlineKeyboardButton(text=texts.t("HAPP_PLATFORM_WINDOWS", "💻 Windows"), callback_data="happ_download_windows")],
        [InlineKeyboardButton(text=texts.BACK, callback_data="happ_download_close")],
    ]

    return InlineKeyboardMarkup(inline_keyboard=buttons)


def get_happ_download_link_keyboard(language: str, link: str) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    buttons = [
        [InlineKeyboardButton(text=texts.t("HAPP_DOWNLOAD_OPEN_LINK", "🔗 Открыть ссылку"), url=link)],
        [InlineKeyboardButton(text=texts.BACK, callback_data="happ_download_back")],
    ]

    return InlineKeyboardMarkup(inline_keyboard=buttons)


def get_back_keyboard(language: str = DEFAULT_LANGUAGE, callback_data: str = "back_to_menu") -> InlineKeyboardMarkup:
    texts = get_texts(language)
    return InlineKeyboardMarkup(inline_keyboard=[
        [InlineKeyboardButton(text=texts.BACK, callback_data=callback_data)]
    ])


def get_server_status_keyboard(
    language: str,
    current_page: int,
    total_pages: int,
) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    keyboard: list[list[InlineKeyboardButton]] = [
        [
            InlineKeyboardButton(
                text=texts.t("SERVER_STATUS_REFRESH", "🔄 Обновить"),
                callback_data=f"server_status_page:{current_page}",
            )
        ]
    ]

    if total_pages > 1:
        nav_row: list[InlineKeyboardButton] = []

        if current_page > 1:
            nav_row.append(
                InlineKeyboardButton(
                    text=texts.t("SERVER_STATUS_PREV_PAGE", "⬅️ Назад"),
                    callback_data=f"server_status_page:{current_page - 1}",
                )
            )

        if current_page < total_pages:
            nav_row.append(
                InlineKeyboardButton(
                    text=texts.t("SERVER_STATUS_NEXT_PAGE", "Вперед ➡️"),
                    callback_data=f"server_status_page:{current_page + 1}",
                )
            )

        if nav_row:
            keyboard.append(nav_row)

    keyboard.append([InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")])

    return InlineKeyboardMarkup(inline_keyboard=keyboard)


def get_insufficient_balance_keyboard(
    language: str = DEFAULT_LANGUAGE,
    resume_callback: str | None = None,
    amount_kopeks: int | None = None,
    has_saved_cart: bool = False,  # Новый параметр для указания наличия сохраненной корзины
) -> InlineKeyboardMarkup:

    texts = get_texts(language)
    keyboard = get_payment_methods_keyboard(amount_kopeks or 0, language)

    back_row_index: int | None = None

    if keyboard.inline_keyboard:
        last_row = keyboard.inline_keyboard[-1]
        if (
            len(last_row) == 1
            and isinstance(last_row[0], InlineKeyboardButton)
            and last_row[0].callback_data in {"menu_balance", "back_to_menu"}
        ):
            keyboard.inline_keyboard[-1][0] = InlineKeyboardButton(
                text=texts.t("PAYMENT_RETURN_HOME_BUTTON", "🏠 На главную"),
                callback_data="back_to_menu",
            )
            back_row_index = len(keyboard.inline_keyboard) - 1

    # Если есть сохраненная корзина, добавляем кнопку возврата к оформлению
    if has_saved_cart:
        return_row = [
            InlineKeyboardButton(
                text=texts.RETURN_TO_SUBSCRIPTION_CHECKOUT,
                callback_data="return_to_saved_cart",
            )
        ]
        insert_index = back_row_index if back_row_index is not None else len(keyboard.inline_keyboard)
        keyboard.inline_keyboard.insert(insert_index, return_row)
    elif resume_callback:
        return_row = [
            InlineKeyboardButton(
                text=texts.RETURN_TO_SUBSCRIPTION_CHECKOUT,
                callback_data=resume_callback,
            )
        ]
        insert_index = back_row_index if back_row_index is not None else len(keyboard.inline_keyboard)
        keyboard.inline_keyboard.insert(insert_index, return_row)

    return keyboard


def get_subscription_keyboard(
    language: str = DEFAULT_LANGUAGE, 
    has_subscription: bool = False, 
    is_trial: bool = False,
    subscription=None
) -> InlineKeyboardMarkup:
    from app.config import settings 
    
    texts = get_texts(language)
    keyboard = []
    has_direct_payment_methods = False

    if has_subscription:
        subscription_link = get_display_subscription_link(subscription) if subscription else None
        if subscription_link:
            connect_mode = settings.CONNECT_BUTTON_MODE

            if connect_mode == "miniapp_subscription":
                keyboard.append([
                    InlineKeyboardButton(
                        text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
                        web_app=types.WebAppInfo(url=subscription_link)
                    )
                ])
            elif connect_mode == "miniapp_custom":
                if settings.MINIAPP_CUSTOM_URL:
                    keyboard.append([
                        InlineKeyboardButton(
                            text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
                            web_app=types.WebAppInfo(url=settings.MINIAPP_CUSTOM_URL)
                        )
                    ])
                else:
                    keyboard.append([
                        InlineKeyboardButton(text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"), callback_data="subscription_connect")
                    ])
            elif connect_mode == "link":
                keyboard.append([
                    InlineKeyboardButton(text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"), url=subscription_link)
                ])
            elif connect_mode == "happ_cryptolink":
                keyboard.append([
                    InlineKeyboardButton(
                        text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
                        callback_data="open_subscription_link",
                    )
                ])
            else:
                keyboard.append([
                    InlineKeyboardButton(text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"), callback_data="subscription_connect")
                ])
        elif settings.CONNECT_BUTTON_MODE == "miniapp_custom":
            keyboard.append([
                InlineKeyboardButton(
                    text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
                    web_app=types.WebAppInfo(url=settings.MINIAPP_CUSTOM_URL)
                )
            ])
        else:
            keyboard.append([
                InlineKeyboardButton(text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"), callback_data="subscription_connect")
            ])

        happ_row = get_happ_download_button_row(texts)
        if happ_row:
            keyboard.append(happ_row)

        if is_trial:
            keyboard.append([
                InlineKeyboardButton(text=texts.MENU_BUY_SUBSCRIPTION, callback_data="subscription_upgrade")
            ])
        else:
            # Проверяем, является ли тариф суточным
            tariff = getattr(subscription, 'tariff', None) if subscription else None
            is_daily_tariff = tariff and getattr(tariff, 'is_daily', False)

            if is_daily_tariff:
                # Для суточного тарифа показываем кнопку паузы/возобновления
                is_paused = getattr(subscription, 'is_daily_paused', False)
                if is_paused:
                    pause_text = texts.t("RESUME_DAILY_BUTTON", "▶️ Возобновить подписку")
                else:
                    pause_text = texts.t("PAUSE_DAILY_BUTTON", "⏸️ Приостановить подписку")
                keyboard.append([
                    InlineKeyboardButton(text=pause_text, callback_data="toggle_daily_subscription_pause")
                ])
            else:
                # Для обычного тарифа: [Продлить] [Автоплатеж]
                keyboard.append([
                    InlineKeyboardButton(text=texts.MENU_EXTEND_SUBSCRIPTION, callback_data="subscription_extend"),
                    InlineKeyboardButton(
                        text=texts.t("AUTOPAY_BUTTON", "💳 Автоплатеж"),
                        callback_data="subscription_autopay",
                    )
                ])

            # Ряд: [Настройки] [Тариф] (если режим тарифов)
            settings_row = [
                InlineKeyboardButton(
                    text=texts.t("SUBSCRIPTION_SETTINGS_BUTTON", "⚙️ Настройки"),
                    callback_data="subscription_settings",
                )
            ]
            if settings.is_tariffs_mode() and subscription:
                # Для суточных тарифов переходим на список тарифов, для обычных - мгновенное переключение
                tariff_callback = "tariff_switch" if is_daily_tariff else "instant_switch"
                settings_row.append(
                    InlineKeyboardButton(
                        text=texts.t("CHANGE_TARIFF_BUTTON", "📦 Тариф"),
                        callback_data=tariff_callback
                    )
                )
            keyboard.append(settings_row)

            # Кнопка докупки трафика для платных подписок
            # В режиме тарифов проверяем tariff_id, в классическом - глобальные настройки
            show_traffic_topup = False
            if subscription and (subscription.traffic_limit_gb or 0) > 0:
                if settings.is_tariffs_mode() and getattr(subscription, 'tariff_id', None):
                    show_traffic_topup = True
                elif settings.is_traffic_topup_enabled() and not settings.is_traffic_topup_blocked():
                    show_traffic_topup = True

            if show_traffic_topup:
                keyboard.append([
                    InlineKeyboardButton(
                        text=texts.t("BUY_TRAFFIC_BUTTON", "📈 Докупить трафик"),
                        callback_data="buy_traffic"
                    )
                ])

    keyboard.append([
        InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)

def get_payment_methods_keyboard_with_cart(
    language: str = "ru",
    amount_kopeks: int = 0,
) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    keyboard = get_payment_methods_keyboard(amount_kopeks, language)
    
    # Добавляем кнопку "Очистить корзину"
    keyboard.inline_keyboard.append([
        InlineKeyboardButton(
            text="🗑️ Очистить корзину и вернуться",
            callback_data="clear_saved_cart"
        )
    ])
    
    # Добавляем кнопку возврата к оформлению подписки
    keyboard.inline_keyboard.insert(-1, [  # Вставляем перед кнопкой "назад"
        InlineKeyboardButton(
            text=texts.RETURN_TO_SUBSCRIPTION_CHECKOUT,
            callback_data="return_to_saved_cart"
        )
    ])
    
    return keyboard

def get_subscription_confirm_keyboard_with_cart(language: str = "ru") -> InlineKeyboardMarkup:
    texts = get_texts(language)
    return InlineKeyboardMarkup(inline_keyboard=[
        [InlineKeyboardButton(
            text="✅ Подтвердить покупку",
            callback_data="subscription_confirm"
        )],
        [InlineKeyboardButton(
            text="🗑️ Очистить корзину",
            callback_data="clear_saved_cart"
        )],
        [InlineKeyboardButton(
            text=texts.BACK,
            callback_data="subscription_config_back"  # Изменили на возврат к настройке
        )]
    ])

def get_insufficient_balance_keyboard_with_cart(
    language: str = "ru",
    amount_kopeks: int = 0,
) -> InlineKeyboardMarkup:
    # Используем обновленную версию с флагом has_saved_cart=True
    keyboard = get_insufficient_balance_keyboard(
        language,
        amount_kopeks=amount_kopeks,
        has_saved_cart=True,
    )

    # Добавляем кнопку очистки корзины в начало
    keyboard.inline_keyboard.insert(
        0,
        [
            InlineKeyboardButton(
                text="🗑️ Очистить корзину и вернуться",
                callback_data="clear_saved_cart",
            )
        ],
    )

    return keyboard

def get_trial_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
    texts = get_texts(language)
    return InlineKeyboardMarkup(inline_keyboard=[
        [
            InlineKeyboardButton(text=texts.t("TRIAL_ACTIVATE_BUTTON", "🎁 Активировать"), callback_data="trial_activate"),
            InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
        ]
    ])


def get_subscription_period_keyboard(
    language: str = DEFAULT_LANGUAGE,
    user: Optional[User] = None
) -> InlineKeyboardMarkup:
    """
    Generate subscription period selection keyboard with personalized pricing.

    Args:
        language: User's language code
        user: User object for personalized discounts (None = default discounts)

    Returns:
        InlineKeyboardMarkup with period buttons showing personalized prices
    """
    from app.utils.price_display import calculate_user_price

    texts = get_texts(language)
    keyboard = []

    available_periods = settings.get_available_subscription_periods()

    for days in available_periods:
        # Get base price for this period
        base_price = PERIOD_PRICES.get(days, 0)

        # Calculate personalized price with user's discounts
        price_info = calculate_user_price(user, base_price, days, "period")

        # Format period description
        period_display = format_period_description(days, language)

        # Format button text with discount display
        button_text = format_price_button(
            period_label=period_display,
            price_info=price_info,
            format_price_func=texts.format_price,
            emphasize=False,
            add_exclamation=False
        )

        keyboard.append([
            InlineKeyboardButton(
                text=button_text,
                callback_data=f"period_{days}"
            )
        ])

    # Кнопка "Простая покупка" была убрана из выбора периода подписки

    keyboard.append([
        InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
    ])

    return InlineKeyboardMarkup(inline_keyboard=keyboard)


def get_traffic_packages_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    import logging
    logger = logging.getLogger(__name__)

    from app.config import settings

    if settings.is_traffic_topup_blocked():
        return get_back_keyboard(language)
    
    logger.info(f"🔍 RAW CONFIG: '{settings.TRAFFIC_PACKAGES_CONFIG}'")
    
    all_packages = settings.get_traffic_packages()
    logger.info(f"🔍 ALL PACKAGES: {all_packages}")
    
    enabled_packages = [pkg for pkg in all_packages if pkg['enabled']]
    disabled_packages = [pkg for pkg in all_packages if not pkg['enabled']]
    
    logger.info(f"🔍 ENABLED: {len(enabled_packages)} packages")
    logger.info(f"🔍 DISABLED: {len(disabled_packages)} packages")
    
    for pkg in disabled_packages:
        logger.info(f"🔍 DISABLED PACKAGE: {pkg['gb']}GB = {pkg['price']} kopeks, enabled={pkg['enabled']}")
    
    texts = get_texts(language)
    keyboard = []
    
    traffic_packages = settings.get_traffic_packages()
    
    for package in traffic_packages:
        gb = package["gb"]
        price = package["price"]  
        enabled = package["enabled"]
        
        if not enabled:
            continue
        
        if gb == 0:
            text = f"♾️ Безлимит - {settings.format_price(package['price'])}"
        else:
            text = f"📊 {gb} ГБ - {settings.format_price(package['price'])}"
        
        keyboard.append([
            InlineKeyboardButton(text=text, callback_data=f"traffic_{gb}")
        ])

    if not keyboard:
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("TRAFFIC_PACKAGES_NOT_CONFIGURED", "⚠️ Пакеты трафика не настроены"), 
                callback_data="no_traffic_packages"
            )
        ])
    
    keyboard.append([
        InlineKeyboardButton(text=texts.BACK, callback_data="subscription_config_back")
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)

def get_countries_keyboard(countries: List[dict], selected: List[str], language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    keyboard = []
    
    for country in countries:
        if not country.get('is_available', True):
            continue 
            
        emoji = "✅" if country['uuid'] in selected else "⚪"
        
        if country['price_kopeks'] > 0:
            price_text = f" (+{texts.format_price(country['price_kopeks'])})"
        else:
            price_text = " (Бесплатно)"
        
        keyboard.append([
            InlineKeyboardButton(
                text=f"{emoji} {country['name']}{price_text}",
                callback_data=f"country_{country['uuid']}"
            )
        ])
    
    if not keyboard:
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("NO_SERVERS_AVAILABLE", "❌ Нет доступных серверов"),
                callback_data="no_servers"
            )
        ])
    
    keyboard.extend([
        [InlineKeyboardButton(text=texts.t("CONTINUE_BUTTON", "✅ Продолжить"), callback_data="countries_continue")],
        [InlineKeyboardButton(text=texts.BACK, callback_data="subscription_config_back")]
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)


def get_devices_keyboard(current: int, language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    keyboard = []
    
    start_devices = settings.DEFAULT_DEVICE_LIMIT
    max_devices = settings.MAX_DEVICES_LIMIT if settings.MAX_DEVICES_LIMIT > 0 else 50
    end_devices = min(max_devices + 1, start_devices + 10)
    
    buttons = []
    
    for devices in range(start_devices, end_devices): 
        price = max(0, devices - settings.DEFAULT_DEVICE_LIMIT) * settings.PRICE_PER_DEVICE
        price_text = f" (+{texts.format_price(price)})" if price > 0 else " (вкл.)"
        emoji = "✅" if devices == current else "⚪"
        
        button_text = f"{emoji} {devices}{price_text}"
        
        buttons.append(
            InlineKeyboardButton(
                text=button_text,
                callback_data=f"devices_{devices}"
            )
        )
    
    for i in range(0, len(buttons), 2):
        if i + 1 < len(buttons):
            keyboard.append([buttons[i], buttons[i + 1]])
        else:
            keyboard.append([buttons[i]])
    
    keyboard.extend([
        [InlineKeyboardButton(text=texts.t("CONTINUE_BUTTON", "✅ Продолжить"), callback_data="devices_continue")],
        [InlineKeyboardButton(text=texts.BACK, callback_data="subscription_config_back")]
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)

def _get_device_declension(count: int) -> str:
    if count % 10 == 1 and count % 100 != 11:
        return "устройство"
    elif count % 10 in [2, 3, 4] and count % 100 not in [12, 13, 14]:
        return "устройства"
    else:
        return "устройств"

def get_subscription_confirm_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    return InlineKeyboardMarkup(inline_keyboard=[
        [
            InlineKeyboardButton(text=texts.CONFIRM, callback_data="subscription_confirm"),
            InlineKeyboardButton(text=texts.CANCEL, callback_data="subscription_cancel")
        ]
    ])


def get_balance_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    
    keyboard = [
        [
            InlineKeyboardButton(text=texts.BALANCE_HISTORY, callback_data="balance_history"),
            InlineKeyboardButton(text=texts.BALANCE_TOP_UP, callback_data="balance_topup")
        ],
        [
            InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
        ]
    ]
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)


def get_payment_methods_keyboard(amount_kopeks: int, language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    keyboard = []
    has_direct_payment_methods = False

    amount_kopeks = max(0, int(amount_kopeks or 0))

    def _build_callback(method: str) -> str:
        if amount_kopeks > 0:
            return f"topup_amount|{method}|{amount_kopeks}"
        return f"topup_{method}"

    if settings.TELEGRAM_STARS_ENABLED:
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("PAYMENT_TELEGRAM_STARS", "⭐ Telegram Stars"),
                callback_data=_build_callback("stars")
            )
        ])
        has_direct_payment_methods = True

    if settings.is_yookassa_enabled():
        if settings.YOOKASSA_SBP_ENABLED:
            keyboard.append([
                InlineKeyboardButton(
                    text=texts.t("PAYMENT_SBP_YOOKASSA", "🏦 Оплатить по СБП (YooKassa)"),
                    callback_data=_build_callback("yookassa_sbp"),
                )
            ])
            has_direct_payment_methods = True

        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("PAYMENT_CARD_YOOKASSA", "💳 Банковская карта (YooKassa)"),
                callback_data=_build_callback("yookassa"),
            )
        ])
        has_direct_payment_methods = True

    if settings.TRIBUTE_ENABLED:
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("PAYMENT_CARD_TRIBUTE", "💳 Банковская карта (Tribute)"),
                callback_data=_build_callback("tribute")
            )
        ])
        has_direct_payment_methods = True

    if settings.is_mulenpay_enabled():
        mulenpay_name = settings.get_mulenpay_display_name()
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t(
                    "PAYMENT_CARD_MULENPAY",
                    "💳 Банковская карта ({mulenpay_name})",
                ).format(mulenpay_name=mulenpay_name),
                callback_data=_build_callback("mulenpay")
            )
        ])
        has_direct_payment_methods = True

    if settings.is_wata_enabled():
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("PAYMENT_CARD_WATA", "💳 Банковская карта (WATA)"),
                callback_data=_build_callback("wata")
            )
        ])
        has_direct_payment_methods = True

    if settings.is_pal24_enabled():
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("PAYMENT_CARD_PAL24", "🏦 СБП (PayPalych)"),
                callback_data=_build_callback("pal24")
            )
        ])
        has_direct_payment_methods = True

    if settings.is_platega_enabled() and settings.get_platega_active_methods():
        platega_name = settings.get_platega_display_name()
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("PAYMENT_PLATEGA", f"💳 {platega_name}"),
                callback_data=_build_callback("platega"),
            )
        ])
        has_direct_payment_methods = True

    if settings.is_cryptobot_enabled():
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("PAYMENT_CRYPTOBOT", "🪙 Криптовалюта (CryptoBot)"),
                callback_data=_build_callback("cryptobot")
            )
        ])
        has_direct_payment_methods = True

    if settings.is_heleket_enabled():
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("PAYMENT_HELEKET", "🪙 Криптовалюта (Heleket)"),
                callback_data=_build_callback("heleket")
            )
        ])
        has_direct_payment_methods = True

    if settings.is_cloudpayments_enabled():
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("PAYMENT_CLOUDPAYMENTS", "💳 Банковская карта (CloudPayments)"),
                callback_data=_build_callback("cloudpayments")
            )
        ])
        has_direct_payment_methods = True

    if settings.is_freekassa_enabled():
        freekassa_name = settings.get_freekassa_display_name()
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("PAYMENT_FREEKASSA", f"💳 {freekassa_name}"),
                callback_data=_build_callback("freekassa")
            )
        ])
        has_direct_payment_methods = True

    if settings.is_support_topup_enabled():
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("PAYMENT_VIA_SUPPORT", "🛠️ Через поддержку"),
                callback_data="topup_support"
            )
        ])

    if not keyboard:
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("PAYMENTS_TEMPORARILY_UNAVAILABLE", "⚠️ Способы оплаты временно недоступны"),
                callback_data="payment_methods_unavailable"
            )
        ])
    elif not has_direct_payment_methods and settings.is_support_topup_enabled():
        keyboard.insert(0, [
            InlineKeyboardButton(
                text=texts.t("PAYMENTS_TEMPORARILY_UNAVAILABLE", "⚠️ Способы оплаты временно недоступны"),
                callback_data="payment_methods_unavailable"
            )
        ])

    keyboard.append([
        InlineKeyboardButton(text=texts.BACK, callback_data="menu_balance")
    ])

    return InlineKeyboardMarkup(inline_keyboard=keyboard)

def get_yookassa_payment_keyboard(
    payment_id: str, 
    amount_kopeks: int, 
    confirmation_url: str,
    language: str = DEFAULT_LANGUAGE
) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    return InlineKeyboardMarkup(inline_keyboard=[
        [
            InlineKeyboardButton(
                text=texts.t("PAY_NOW_BUTTON", "💳 Оплатить"),
                url=confirmation_url
            )
        ],
        [
            InlineKeyboardButton(
                text=texts.t("CHECK_STATUS_BUTTON", "📊 Проверить статус"),
                callback_data=f"check_yookassa_status_{payment_id}"
            )
        ],
        [
            InlineKeyboardButton(
                text=texts.t("MY_BALANCE_BUTTON", "💰 Мой баланс"),
                callback_data="menu_balance"
            )
        ]
    ])

def get_autopay_notification_keyboard(subscription_id: int, language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)

    return InlineKeyboardMarkup(inline_keyboard=[
        [
            build_miniapp_or_callback_button(
                text=texts.t("TOPUP_BALANCE_BUTTON", "💳 Пополнить баланс"),
                callback_data="balance_topup"
            )
        ],
        [
            build_miniapp_or_callback_button(
                text=texts.t("MY_SUBSCRIPTION_BUTTON", "📱 Моя подписка"),
                callback_data="menu_subscription"
            )
        ]
    ])

def get_subscription_expiring_keyboard(subscription_id: int, language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)

    return InlineKeyboardMarkup(inline_keyboard=[
        [
            build_miniapp_or_callback_button(
                text=texts.MENU_EXTEND_SUBSCRIPTION,
                callback_data="subscription_extend"
            )
        ],
        [
            build_miniapp_or_callback_button(
                text=texts.t("TOPUP_BALANCE_BUTTON", "💳 Пополнить баланс"),
                callback_data="balance_topup"
            )
        ],
        [
            build_miniapp_or_callback_button(
                text=texts.t("MY_SUBSCRIPTION_BUTTON", "📱 Моя подписка"),
                callback_data="menu_subscription"
            )
        ]
    ])

def get_referral_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)

    keyboard = [
        [
            InlineKeyboardButton(
                text=texts.t("CREATE_INVITE_BUTTON", "📝 Создать приглашение"),
                callback_data="referral_create_invite"
            )
        ],
        [
            InlineKeyboardButton(
                text=texts.t("SHOW_QR_BUTTON", "📱 Показать QR код"),
                callback_data="referral_show_qr"
            )
        ],
        [
            InlineKeyboardButton(
                text=texts.t("REFERRAL_LIST_BUTTON", "👥 Список рефералов"),
                callback_data="referral_list"
            )
        ],
        [
            InlineKeyboardButton(
                text=texts.t("REFERRAL_ANALYTICS_BUTTON", "📊 Аналитика"),
                callback_data="referral_analytics"
            )
        ],
    ]

    # Добавляем кнопку вывода, если включена
    if settings.is_referral_withdrawal_enabled():
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("REFERRAL_WITHDRAWAL_BUTTON", "💸 Запросить вывод"),
                callback_data="referral_withdrawal"
            )
        ])

    keyboard.append([
        InlineKeyboardButton(
            text=texts.BACK,
            callback_data="back_to_menu"
        )
    ])

    return InlineKeyboardMarkup(inline_keyboard=keyboard)


def get_support_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    try:
        from app.services.support_settings_service import SupportSettingsService
        tickets_enabled = SupportSettingsService.is_tickets_enabled()
        contact_enabled = SupportSettingsService.is_contact_enabled()
    except Exception:
        tickets_enabled = True
        contact_enabled = True
    rows: list[list[InlineKeyboardButton]] = []
    # Tickets
    if tickets_enabled:
        rows.append([
            InlineKeyboardButton(
                text=texts.t("CREATE_TICKET_BUTTON", "🎫 Создать тикет"),
                callback_data="create_ticket"
            )
        ])
        rows.append([
            InlineKeyboardButton(
                text=texts.t("MY_TICKETS_BUTTON", "📋 Мои тикеты"),
                callback_data="my_tickets"
            )
        ])
    # Direct contact
    if contact_enabled and settings.get_support_contact_url():
        rows.append([
            InlineKeyboardButton(
                text=texts.t("CONTACT_SUPPORT_BUTTON", "💬 Связаться с поддержкой"),
                url=settings.get_support_contact_url() or "https://t.me/"
            )
        ])
    rows.append([InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")])
    return InlineKeyboardMarkup(inline_keyboard=rows)


def get_pagination_keyboard(
    current_page: int,
    total_pages: int,
    callback_prefix: str,
    language: str = DEFAULT_LANGUAGE
) -> List[List[InlineKeyboardButton]]:
    texts = get_texts(language)
    keyboard = []
    
    if total_pages > 1:
        row = []
        
        if current_page > 1:
            row.append(InlineKeyboardButton(
                text=texts.t("PAGINATION_PREV", "⬅️"),
                callback_data=f"{callback_prefix}_page_{current_page - 1}"
            ))
        
        row.append(InlineKeyboardButton(
            text=f"{current_page}/{total_pages}",
            callback_data="current_page"
        ))
        
        if current_page < total_pages:
            row.append(InlineKeyboardButton(
                text=texts.t("PAGINATION_NEXT", "➡️"),
                callback_data=f"{callback_prefix}_page_{current_page + 1}"
            ))
        
        keyboard.append(row)
    
    return keyboard

def get_confirmation_keyboard(
    confirm_data: str,
    cancel_data: str = "cancel",
    language: str = DEFAULT_LANGUAGE
) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    return InlineKeyboardMarkup(inline_keyboard=[
        [
            InlineKeyboardButton(text=texts.YES, callback_data=confirm_data),
            InlineKeyboardButton(text=texts.NO, callback_data=cancel_data)
        ]
    ])


def get_autopay_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    return InlineKeyboardMarkup(inline_keyboard=[
        [
            InlineKeyboardButton(text=texts.t("ENABLE_BUTTON", "✅ Включить"), callback_data="autopay_enable"),
            InlineKeyboardButton(text=texts.t("DISABLE_BUTTON", "❌ Выключить"), callback_data="autopay_disable")
        ],
        [
            InlineKeyboardButton(text=texts.t("AUTOPAY_SET_DAYS_BUTTON", "⚙️ Настроить дни"), callback_data="autopay_set_days")
        ],
        [
            InlineKeyboardButton(text=texts.BACK, callback_data="menu_subscription")
        ]
    ])


def get_autopay_days_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    keyboard = []
    
    for days in [1, 3, 7, 14]:
        keyboard.append([
            InlineKeyboardButton(
                text=f"{days} {_get_days_word(days)}",
                callback_data=f"autopay_days_{days}"
            )
        ])
    
    keyboard.append([
        InlineKeyboardButton(text=texts.BACK, callback_data="subscription_autopay")
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)


def _get_days_word(days: int) -> str:
    if days % 10 == 1 and days % 100 != 11:
        return "день"
    if 2 <= days % 10 <= 4 and not (12 <= days % 100 <= 14):
        return "дня"
    return "дней"



# Deprecated: get_extend_subscription_keyboard() was removed.
# Use get_extend_subscription_keyboard_with_prices() instead for personalized pricing.


def get_add_traffic_keyboard(
    language: str = DEFAULT_LANGUAGE,
    subscription_end_date: datetime = None,
    discount_percent: int = 0,
) -> InlineKeyboardMarkup:
    from app.utils.pricing_utils import get_remaining_months
    from app.config import settings
    texts = get_texts(language)
    
    months_multiplier = 1
    period_text = ""
    if subscription_end_date:
        months_multiplier = get_remaining_months(subscription_end_date)
        if months_multiplier > 1:
            period_text = f" (за {months_multiplier} мес)"
    
    packages = settings.get_traffic_topup_packages()
    enabled_packages = [pkg for pkg in packages if pkg['enabled']]
    
    if not enabled_packages:
        return InlineKeyboardMarkup(inline_keyboard=[
            [InlineKeyboardButton(
                text=texts.t("NO_TRAFFIC_PACKAGES", "❌ Нет доступных пакетов"),
                callback_data="no_traffic_packages"
            )],
            [InlineKeyboardButton(
                text=texts.BACK,
                callback_data="menu_subscription"
            )]
        ])
    
    buttons = []
    
    for package in enabled_packages:
        gb = package['gb']
        price_per_month = package['price']
        discounted_per_month, discount_per_month = apply_percentage_discount(
            price_per_month,
            discount_percent,
        )
        total_price = discounted_per_month * months_multiplier
        total_discount = discount_per_month * months_multiplier

        if gb == 0:
            if language == "ru":
                text = f"♾️ Безлимитный трафик - {total_price//100} ₽{period_text}"
            else:
                text = f"♾️ Unlimited traffic - {total_price//100} ₽{period_text}"
        else:
            if language == "ru":
                text = f"📊 +{gb} ГБ трафика - {total_price//100} ₽{period_text}"
            else:
                text = f"📊 +{gb} GB traffic - {total_price//100} ₽{period_text}"

        if discount_percent > 0 and total_discount > 0:
            text += f" (скидка {discount_percent}%: -{total_discount//100}₽)"

        buttons.append([
            InlineKeyboardButton(text=text, callback_data=f"add_traffic_{gb}")
        ])
    
    buttons.append([
        InlineKeyboardButton(
            text=texts.BACK,
            callback_data="menu_subscription"
        )
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=buttons)


def get_add_traffic_keyboard_from_tariff(
    language: str,
    packages: dict,  # {gb: price_kopeks}
    subscription_end_date: datetime = None,
    discount_percent: int = 0,
) -> InlineKeyboardMarkup:
    """
    Клавиатура для докупки трафика из настроек тарифа.

    Args:
        language: Язык интерфейса
        packages: Словарь {ГБ: цена_в_копейках} из тарифа
        subscription_end_date: Дата окончания подписки для расчета цены
        discount_percent: Процент скидки
    """
    from app.utils.pricing_utils import get_remaining_months

    texts = get_texts(language)

    months_multiplier = 1
    period_text = ""
    if subscription_end_date:
        months_multiplier = get_remaining_months(subscription_end_date)
        if months_multiplier > 1:
            period_text = f" (за {months_multiplier} мес)"

    if not packages:
        return InlineKeyboardMarkup(inline_keyboard=[
            [InlineKeyboardButton(
                text=texts.t("NO_TRAFFIC_PACKAGES", "❌ Нет доступных пакетов"),
                callback_data="no_traffic_packages"
            )],
            [InlineKeyboardButton(
                text=texts.BACK,
                callback_data="menu_subscription"
            )]
        ])

    buttons = []

    # Сортируем пакеты по размеру
    sorted_packages = sorted(packages.items(), key=lambda x: x[0])

    for gb, price_per_month in sorted_packages:
        discounted_per_month, discount_per_month = apply_percentage_discount(
            price_per_month,
            discount_percent,
        )
        total_price = discounted_per_month * months_multiplier
        total_discount = discount_per_month * months_multiplier

        if language == "ru":
            text = f"📊 +{gb} ГБ трафика - {total_price // 100} ₽{period_text}"
        else:
            text = f"📊 +{gb} GB traffic - {total_price // 100} ₽{period_text}"

        if discount_percent > 0 and total_discount > 0:
            text += f" (скидка {discount_percent}%: -{total_discount // 100}₽)"

        buttons.append([
            InlineKeyboardButton(text=text, callback_data=f"add_traffic_{gb}")
        ])

    buttons.append([
        InlineKeyboardButton(
            text=texts.BACK,
            callback_data="menu_subscription"
        )
    ])

    return InlineKeyboardMarkup(inline_keyboard=buttons)


def get_change_devices_keyboard(
    current_devices: int,
    language: str = DEFAULT_LANGUAGE,
    subscription_end_date: datetime = None,
    discount_percent: int = 0,
    tariff=None,  # Тариф для цены за устройство
) -> InlineKeyboardMarkup:
    from app.utils.pricing_utils import get_remaining_months
    from app.config import settings
    texts = get_texts(language)

    months_multiplier = 1
    period_text = ""
    if subscription_end_date:
        months_multiplier = get_remaining_months(subscription_end_date)
        if months_multiplier > 1:
            period_text = f" (за {months_multiplier} мес)"

    # Используем цену из тарифа если есть, иначе глобальную настройку
    tariff_device_price = getattr(tariff, 'device_price_kopeks', None) if tariff else None
    if tariff and tariff_device_price:
        device_price_per_month = tariff_device_price
        # Для тарифов все устройства платные (нет бесплатного лимита)
        default_device_limit = 0
    else:
        device_price_per_month = settings.PRICE_PER_DEVICE
        default_device_limit = settings.DEFAULT_DEVICE_LIMIT

    buttons = []

    min_devices = 1
    max_devices = settings.MAX_DEVICES_LIMIT if settings.MAX_DEVICES_LIMIT > 0 else 20

    start_range = max(1, min(current_devices - 3, max_devices - 6))
    end_range = min(max_devices + 1, max(current_devices + 4, 7))

    for devices_count in range(start_range, end_range):
        if devices_count == current_devices:
            emoji = "✅"
            action_text = " (текущее)"
            price_text = ""
        elif devices_count > current_devices:
            emoji = "➕"
            additional_devices = devices_count - current_devices

            current_chargeable = max(0, current_devices - default_device_limit)
            new_chargeable = max(0, devices_count - default_device_limit)
            chargeable_devices = new_chargeable - current_chargeable

            if chargeable_devices > 0:
                price_per_month = chargeable_devices * device_price_per_month
                discounted_per_month, discount_per_month = apply_percentage_discount(
                    price_per_month,
                    discount_percent,
                )
                total_price = discounted_per_month * months_multiplier
                price_text = f" (+{total_price//100}₽{period_text})"
                if discount_percent > 0 and discount_per_month * months_multiplier > 0:
                    price_text += (
                        f" (скидка {discount_percent}%:"
                        f" -{(discount_per_month * months_multiplier)//100}₽)"
                    )
                action_text = ""
            else:
                price_text = " (бесплатно)"
                action_text = ""
        else:
            emoji = "➖"
            action_text = ""
            price_text = " (без возврата)"

        button_text = f"{emoji} {devices_count} устр.{action_text}{price_text}"

        buttons.append([
            InlineKeyboardButton(text=button_text, callback_data=f"change_devices_{devices_count}")
        ])

    if current_devices < start_range or current_devices >= end_range:
        current_button = f"✅ {current_devices} устр. (текущее)"
        buttons.insert(0, [
            InlineKeyboardButton(text=current_button, callback_data=f"change_devices_{current_devices}")
        ])

    buttons.append([
        InlineKeyboardButton(
            text=texts.BACK,
            callback_data="subscription_settings"
        )
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=buttons)

def get_confirm_change_devices_keyboard(new_devices_count: int, price: int, language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    
    return InlineKeyboardMarkup(inline_keyboard=[
        [
            InlineKeyboardButton(
                text=texts.t("CONFIRM_CHANGE_BUTTON", "✅ Подтвердить изменение"),
                callback_data=f"confirm_change_devices_{new_devices_count}_{price}"
            )
        ],
        [
            InlineKeyboardButton(
                text=texts.CANCEL,
                callback_data="subscription_settings"
            )
        ]
    ])


def get_reset_traffic_confirm_keyboard(
    price_kopeks: int, 
    language: str = DEFAULT_LANGUAGE,
    has_enough_balance: bool = True,
    missing_kopeks: int = 0,
) -> InlineKeyboardMarkup:
    from app.config import settings

    if settings.is_traffic_topup_blocked():
        return get_back_keyboard(language)
    
    texts = get_texts(language)
    buttons = []
    
    if has_enough_balance:
        # Достаточно средств - показываем кнопку сброса
        buttons.append([
            InlineKeyboardButton(
                text=f"✅ Сбросить за {settings.format_price(price_kopeks)}", 
                callback_data="confirm_reset_traffic"
            )
        ])
    else:
        # Не хватает средств - показываем кнопку пополнения
        buttons.append([
            InlineKeyboardButton(
                text=texts.t("TOPUP_BALANCE_BUTTON", "💳 Пополнить баланс"),
                callback_data=f"topup_amount_{missing_kopeks}"
            )
        ])
    
    buttons.append([
        InlineKeyboardButton(
            text=texts.BACK,
            callback_data="subscription_settings",
        )
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=buttons)

def get_manage_countries_keyboard(
    countries: List[dict],
    selected: List[str],
    current_subscription_countries: List[str],
    language: str = DEFAULT_LANGUAGE,
    subscription_end_date: datetime = None,
    discount_percent: int = 0,
) -> InlineKeyboardMarkup:
    from app.utils.pricing_utils import get_remaining_months

    texts = get_texts(language)

    months_multiplier = 1
    if subscription_end_date:
        months_multiplier = get_remaining_months(subscription_end_date)
        logger.info(f"🔍 Расчет для управления странами: осталось {months_multiplier} месяцев до {subscription_end_date}")
    
    buttons = []
    total_cost = 0
    
    for country in countries:
        if not country.get('is_available', True):
            continue

        uuid = country['uuid']
        name = country['name']
        price_per_month = country['price_kopeks']

        discounted_per_month, discount_per_month = apply_percentage_discount(
            price_per_month,
            discount_percent,
        )

        if uuid in current_subscription_countries:
            if uuid in selected:
                icon = "✅"
            else:
                icon = "➖"
        else:
            if uuid in selected:
                icon = "➕"
                total_cost += discounted_per_month * months_multiplier
            else:
                icon = "⚪"

        if uuid not in current_subscription_countries and uuid in selected:
            total_price = discounted_per_month * months_multiplier
            if months_multiplier > 1:
                price_text = (
                    f" ({discounted_per_month//100}₽/мес × {months_multiplier} = {total_price//100}₽)"
                )
                logger.info(
                    "🔍 Сервер %s: %.2f₽/мес × %s мес = %.2f₽ (скидка %.2f₽)",
                    name,
                    discounted_per_month / 100,
                    months_multiplier,
                    total_price / 100,
                    (discount_per_month * months_multiplier) / 100,
                )
            else:
                price_text = f" ({total_price//100}₽)"
            if discount_percent > 0 and discount_per_month * months_multiplier > 0:
                price_text += (
                    f" (скидка {discount_percent}%:"
                    f" -{(discount_per_month * months_multiplier)//100}₽)"
                )
            display_name = f"{icon} {name}{price_text}"
        else:
            display_name = f"{icon} {name}"
        
        buttons.append([
            InlineKeyboardButton(
                text=display_name,
                callback_data=f"country_manage_{uuid}"
            )
        ])
    
    if total_cost > 0:
        apply_text = f"✅ Применить изменения ({total_cost//100} ₽)"
        logger.info(f"🔍 Общая стоимость новых серверов: {total_cost/100}₽")
    else:
        apply_text = "✅ Применить изменения"
    
    buttons.append([
        InlineKeyboardButton(text=apply_text, callback_data="countries_apply")
    ])
    
    buttons.append([
        InlineKeyboardButton(
            text=texts.BACK,
            callback_data="menu_subscription"
        )
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=buttons)

def get_device_selection_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    from app.config import settings
    texts = get_texts(language)
    
    keyboard = [
        [
            InlineKeyboardButton(text=texts.t("DEVICE_GUIDE_IOS", "📱 iOS (iPhone/iPad)"), callback_data="device_guide_ios"),
            InlineKeyboardButton(text=texts.t("DEVICE_GUIDE_ANDROID", "🤖 Android"), callback_data="device_guide_android")
        ],
        [
            InlineKeyboardButton(text=texts.t("DEVICE_GUIDE_WINDOWS", "💻 Windows"), callback_data="device_guide_windows"),
            InlineKeyboardButton(text=texts.t("DEVICE_GUIDE_MAC", "🎯 macOS"), callback_data="device_guide_mac")
        ],
        [
            InlineKeyboardButton(text=texts.t("DEVICE_GUIDE_ANDROID_TV", "📺 Android TV"), callback_data="device_guide_tv"),
            InlineKeyboardButton(text=texts.t("DEVICE_GUIDE_APPLE_TV", "📺 Apple TV"), callback_data="device_guide_appletv")
        ]
    ]
    
    if settings.CONNECT_BUTTON_MODE == "guide":
        keyboard.append([
            InlineKeyboardButton(text=texts.t("SHOW_SUBSCRIPTION_LINK", "📋 Показать ссылку подписки"), callback_data="open_subscription_link")
        ])
    
    keyboard.append([
        InlineKeyboardButton(text=texts.BACK, callback_data="menu_subscription")
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)


def get_connection_guide_keyboard(
    subscription_url: str,
    app: dict,
    device_type: str,
    language: str = DEFAULT_LANGUAGE,
    has_other_apps: bool = False,
) -> InlineKeyboardMarkup:
    from app.handlers.subscription import create_deep_link
    texts = get_texts(language)

    keyboard = []

    if 'installationStep' in app and 'buttons' in app['installationStep']:
        app_buttons = []
        for button in app['installationStep']['buttons']:
            button_text = _get_localized_value(button.get('buttonText'), language)
            button_link = button.get('buttonLink')

            if not button_text or not button_link:
                continue

            app_buttons.append(
                InlineKeyboardButton(text=f"📥 {button_text}", url=button_link)
            )
            if len(app_buttons) == 2:
                keyboard.append(app_buttons)
                app_buttons = []

        if app_buttons:
            keyboard.append(app_buttons)

    additional_before_buttons = _build_additional_buttons(
        app.get('additionalBeforeAddSubscriptionStep'),
        language,
    )

    for button in additional_before_buttons:
        keyboard.append([button])

    connect_link = create_deep_link(app, subscription_url)

    if connect_link:
        connect_button = InlineKeyboardButton(
            text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
            url=connect_link,
        )
    elif settings.is_happ_cryptolink_mode():
        connect_button = InlineKeyboardButton(
            text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
            callback_data="open_subscription_link",
        )
    else:
        connect_button = InlineKeyboardButton(
            text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
            url=subscription_url,
        )

    keyboard.append([connect_button])

    additional_after_buttons = _build_additional_buttons(
        app.get('additionalAfterAddSubscriptionStep'),
        language,
    )

    for button in additional_after_buttons:
        keyboard.append([button])

    if has_other_apps:
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("OTHER_APPS_BUTTON", "📋 Другие приложения"),
                callback_data=f"app_list_{device_type}",
            )
        ])

    keyboard.extend([
        [
            InlineKeyboardButton(text=texts.t("CHOOSE_ANOTHER_DEVICE", "📱 Выбрать другое устройство"), callback_data="subscription_connect")
        ],
        [
            InlineKeyboardButton(text=texts.t("BACK_TO_SUBSCRIPTION", "⬅️ К подписке"), callback_data="menu_subscription")
        ]
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)


def get_app_selection_keyboard(
    device_type: str, 
    apps: list, 
    language: str = DEFAULT_LANGUAGE
) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    keyboard = []
    
    for app in apps:
        app_name = app['name']
        if app.get('isFeatured', False):
            app_name = f"⭐ {app_name}"
        
        keyboard.append([
            InlineKeyboardButton(
                text=app_name, 
                callback_data=f"app_{device_type}_{app['id']}"
            )
        ])
    
    keyboard.extend([
        [
            InlineKeyboardButton(text=texts.t("CHOOSE_ANOTHER_DEVICE", "📱 Выбрать другое устройство"), callback_data="subscription_connect")
        ],
        [
            InlineKeyboardButton(text=texts.t("BACK_TO_SUBSCRIPTION", "⬅️ К подписке"), callback_data="menu_subscription")
        ]
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)


def get_specific_app_keyboard(
    subscription_url: str,
    app: dict,
    device_type: str,
    language: str = DEFAULT_LANGUAGE
) -> InlineKeyboardMarkup:
    from app.handlers.subscription import create_deep_link
    texts = get_texts(language)

    keyboard = []

    if 'installationStep' in app and 'buttons' in app['installationStep']:
        app_buttons = []
        for button in app['installationStep']['buttons']:
            button_text = _get_localized_value(button.get('buttonText'), language)
            button_link = button.get('buttonLink')

            if not button_text or not button_link:
                continue

            app_buttons.append(
                InlineKeyboardButton(text=f"📥 {button_text}", url=button_link)
            )
            if len(app_buttons) == 2:
                keyboard.append(app_buttons)
                app_buttons = []

        if app_buttons:
            keyboard.append(app_buttons)

    additional_before_buttons = _build_additional_buttons(
        app.get('additionalBeforeAddSubscriptionStep'),
        language,
    )

    for button in additional_before_buttons:
        keyboard.append([button])

    connect_link = create_deep_link(app, subscription_url)

    if connect_link:
        connect_button = InlineKeyboardButton(
            text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
            url=connect_link,
        )
    elif settings.is_happ_cryptolink_mode():
        connect_button = InlineKeyboardButton(
            text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
            callback_data="open_subscription_link",
        )
    else:
        connect_button = InlineKeyboardButton(
            text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
            url=subscription_url,
        )

    keyboard.append([connect_button])

    additional_after_buttons = _build_additional_buttons(
        app.get('additionalAfterAddSubscriptionStep'),
        language,
    )

    for button in additional_after_buttons:
        keyboard.append([button])

    keyboard.extend([
        [
            InlineKeyboardButton(text=texts.t("OTHER_APPS_BUTTON", "📋 Другие приложения"), callback_data=f"app_list_{device_type}")
        ],
        [
            InlineKeyboardButton(text=texts.t("CHOOSE_ANOTHER_DEVICE", "📱 Выбрать другое устройство"), callback_data="subscription_connect")
        ],
        [
            InlineKeyboardButton(text=texts.t("BACK_TO_SUBSCRIPTION", "⬅️ К подписке"), callback_data="menu_subscription")
        ]
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)

def get_extend_subscription_keyboard_with_prices(language: str, prices: dict) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    keyboard = []

    available_periods = settings.get_available_renewal_periods()

    for days in available_periods:
        if days not in prices:
            continue

        price_info = prices[days]

        if isinstance(price_info, dict):
            final_price = price_info.get("final")
            original_price = price_info.get("original", 0)
            if final_price is None:
                final_price = price_info.get("original", 0)
        else:
            final_price = price_info
            original_price = price_info

        period_display = format_period_description(days, language)

        # Create PriceInfo from already calculated prices
        # Note: original_price and final_price are calculated in the handler
        discount_percent = 0
        if original_price > final_price and original_price > 0:
            discount_percent = ((original_price - final_price) * 100) // original_price

        price_info_obj = PriceInfo(
            base_price=original_price,
            final_price=final_price,
            discount_percent=discount_percent
        )

        # Format button using unified system
        button_text = format_price_button(
            period_label=period_display,
            price_info=price_info_obj,
            format_price_func=texts.format_price,
            emphasize=False,
            add_exclamation=False
        )

        keyboard.append([
            InlineKeyboardButton(
                text=button_text,
                callback_data=f"extend_period_{days}"
            )
        ])

    keyboard.append([
        InlineKeyboardButton(text=texts.BACK, callback_data="menu_subscription")
    ])

    return InlineKeyboardMarkup(inline_keyboard=keyboard)

def get_cryptobot_payment_keyboard(
    payment_id: str,
    local_payment_id: int,
    amount_usd: float,
    asset: str,
    bot_invoice_url: str,
    language: str = DEFAULT_LANGUAGE
) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    return InlineKeyboardMarkup(inline_keyboard=[
        [
            InlineKeyboardButton(
                text=texts.t("PAY_WITH_COINS_BUTTON", "🪙 Оплатить"),
                url=bot_invoice_url
            )
        ],
        [
            InlineKeyboardButton(
                text=texts.t("CHECK_STATUS_BUTTON", "📊 Проверить статус"),
                callback_data=f"check_cryptobot_{local_payment_id}"
            )
        ],
        [
            InlineKeyboardButton(
                text=texts.t("MY_BALANCE_BUTTON", "💰 Мой баланс"),
                callback_data="menu_balance"
            )
        ]
    ])

def get_devices_management_keyboard(
    devices: List[dict], 
    pagination,
    language: str = DEFAULT_LANGUAGE
) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    
    keyboard = []
    
    for i, device in enumerate(devices):
        platform = device.get('platform', 'Unknown')
        device_model = device.get('deviceModel', 'Unknown')
        device_info = f"{platform} - {device_model}"
        
        if len(device_info) > 25:
            device_info = device_info[:22] + "..."
        
        keyboard.append([
            InlineKeyboardButton(
                text=f"🔄 {device_info}",
                callback_data=f"reset_device_{i}_{pagination.page}"
            )
        ])
    
    if pagination.total_pages > 1:
        nav_row = []
        
        if pagination.has_prev:
            nav_row.append(
                InlineKeyboardButton(
                    text=texts.t("PAGINATION_PREV", "⬅️"),
                    callback_data=f"devices_page_{pagination.prev_page}"
                )
            )

        nav_row.append(
            InlineKeyboardButton(
                text=f"{pagination.page}/{pagination.total_pages}",
                callback_data="current_page"
            )
        )
        
        if pagination.has_next:
            nav_row.append(
                InlineKeyboardButton(
                    text=texts.t("PAGINATION_NEXT", "➡️"),
                    callback_data=f"devices_page_{pagination.next_page}"
                )
            )
        
        keyboard.append(nav_row)
    
    keyboard.append([
        InlineKeyboardButton(
            text=texts.t("RESET_ALL_DEVICES_BUTTON", "🔄 Сбросить все устройства"),
            callback_data="reset_all_devices"
        )
    ])
    
    keyboard.append([
        InlineKeyboardButton(
            text=texts.BACK,
            callback_data="subscription_settings"
        )
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)


def get_updated_subscription_settings_keyboard(
    language: str = DEFAULT_LANGUAGE,
    show_countries_management: bool = True,
    tariff=None,  # Тариф подписки (если есть - ограничиваем настройки)
    subscription=None,  # Подписка (для проверки суточной паузы)
) -> InlineKeyboardMarkup:
    from app.config import settings

    texts = get_texts(language)
    keyboard = []

    # Если подписка на тарифе - отключаем страны, модем, трафик
    has_tariff = tariff is not None

    # Для суточных тарифов кнопка паузы теперь в главном меню подписки

    if show_countries_management and not has_tariff:
        keyboard.append([
            InlineKeyboardButton(text=texts.t("ADD_COUNTRIES_BUTTON", "🌐 Добавить страны"), callback_data="subscription_add_countries")
        ])

    if settings.is_traffic_selectable() and not has_tariff:
        keyboard.append([
            InlineKeyboardButton(text=texts.t("RESET_TRAFFIC_BUTTON", "🔄 Сбросить трафик"), callback_data="subscription_reset_traffic")
        ])
        keyboard.append([
            InlineKeyboardButton(text=texts.t("SWITCH_TRAFFIC_BUTTON", "🔄 Переключить трафик"), callback_data="subscription_switch_traffic")
        ])

    # Устройства: для тарифов - только если указана цена за устройство
    if has_tariff:
        tariff_device_price = getattr(tariff, 'device_price_kopeks', None)
        if tariff_device_price is not None and tariff_device_price > 0:
            keyboard.append([
                InlineKeyboardButton(
                    text=texts.t("CHANGE_DEVICES_BUTTON", "📱 Изменить устройства"),
                    callback_data="subscription_change_devices"
                )
            ])
    elif settings.is_devices_selection_enabled():
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("CHANGE_DEVICES_BUTTON", "📱 Изменить устройства"),
                callback_data="subscription_change_devices"
            )
        ])

    if settings.is_modem_enabled() and not has_tariff:
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("MODEM_BUTTON", "📡 Модем"),
                callback_data="subscription_modem"
            )
        ])

    keyboard.append([
        InlineKeyboardButton(
            text=texts.t("MANAGE_DEVICES_BUTTON", "🔧 Управление устройствами"),
            callback_data="subscription_manage_devices"
        )
    ])

    keyboard.append([
        InlineKeyboardButton(text=texts.BACK, callback_data="menu_subscription")
    ])

    return InlineKeyboardMarkup(inline_keyboard=keyboard)


def get_device_reset_confirm_keyboard(device_info: str, device_index: int, page: int, language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)

    return InlineKeyboardMarkup(inline_keyboard=[
        [
            InlineKeyboardButton(
                text=texts.t("RESET_DEVICE_CONFIRM_BUTTON", "✅ Да, сбросить это устройство"), 
                callback_data=f"confirm_reset_device_{device_index}_{page}"
            )
        ],
        [
            InlineKeyboardButton(
                text=texts.CANCEL, 
                callback_data=f"devices_page_{page}"
            )
        ]
    ])


def get_device_management_help_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)

    return InlineKeyboardMarkup(inline_keyboard=[
        [
            InlineKeyboardButton(
                text=texts.t("DEVICE_CONNECTION_HELP", "❓ Как подключить устройство заново?"),
                callback_data="device_connection_help"
            )
        ],
        [
            InlineKeyboardButton(
                text=texts.t("MANAGE_DEVICES_BUTTON", "🔧 Управление устройствами"),
                callback_data="subscription_manage_devices"
            )
        ],
        [
            InlineKeyboardButton(
                text=texts.t("BACK_TO_SUBSCRIPTION", "⬅️ К подписке"),
                callback_data="menu_subscription"
            )
        ]
    ])


# ==================== TICKET KEYBOARDS ====================

def get_ticket_cancel_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    return InlineKeyboardMarkup(inline_keyboard=[
        [
            InlineKeyboardButton(
                text=texts.t("CANCEL_TICKET_CREATION", "❌ Отменить создание тикета"),
                callback_data="cancel_ticket_creation"
            )
        ]
    ])


def get_my_tickets_keyboard(
    tickets: List[dict],
    current_page: int = 1,
    total_pages: int = 1,
    language: str = DEFAULT_LANGUAGE,
    page_prefix: str = "my_tickets_page_"
) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    keyboard = []
    
    for ticket in tickets:
        status_emoji = ticket.get('status_emoji', '❓')
        # Override status emoji for closed tickets in admin list
        if ticket.get('is_closed', False):
            status_emoji = '✅'
        title = ticket.get('title', 'Без названия')[:25]
        button_text = f"{status_emoji} #{ticket['id']} {title}"
        
        keyboard.append([
            InlineKeyboardButton(
                text=button_text,
                callback_data=f"view_ticket_{ticket['id']}"
            )
        ])
    
    # Пагинация
    if total_pages > 1:
        nav_row = []
        
        if current_page > 1:
            nav_row.append(
                InlineKeyboardButton(
                    text=texts.t("PAGINATION_PREV", "⬅️"),
                    callback_data=f"{page_prefix}{current_page - 1}"
                )
            )
        
        nav_row.append(
            InlineKeyboardButton(
                text=f"{current_page}/{total_pages}",
                callback_data="current_page"
            )
        )
        
        if current_page < total_pages:
            nav_row.append(
                InlineKeyboardButton(
                    text=texts.t("PAGINATION_NEXT", "➡️"),
                    callback_data=f"{page_prefix}{current_page + 1}"
                )
            )
        
        keyboard.append(nav_row)
    
    keyboard.append([
        InlineKeyboardButton(text=texts.BACK, callback_data="menu_support")
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)


def get_ticket_view_keyboard(
    ticket_id: int,
    is_closed: bool = False,
    language: str = DEFAULT_LANGUAGE
) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    keyboard = []
    
    if not is_closed:
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("REPLY_TO_TICKET", "💬 Ответить"),
                callback_data=f"reply_ticket_{ticket_id}"
            )
        ])
    
    if not is_closed:
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("CLOSE_TICKET", "🔒 Закрыть тикет"),
                callback_data=f"close_ticket_{ticket_id}"
            )
        ])
    
    keyboard.append([
        InlineKeyboardButton(text=texts.BACK, callback_data="my_tickets")
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)


def get_ticket_reply_cancel_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    return InlineKeyboardMarkup(inline_keyboard=[
        [
            InlineKeyboardButton(
                text=texts.t("CANCEL_REPLY", "❌ Отменить ответ"),
                callback_data="cancel_ticket_reply"
            )
        ]
    ])


# ==================== ADMIN TICKET KEYBOARDS ====================

def get_admin_tickets_keyboard(
    tickets: List[dict],
    current_page: int = 1,
    total_pages: int = 1,
    language: str = DEFAULT_LANGUAGE,
    scope: str = "all",
    *,
    back_callback: str = "admin_submenu_support"
) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    keyboard = []
    
    # Разделяем открытые/закрытые
    open_rows = []
    closed_rows = []
    for ticket in tickets:
        status_emoji = ticket.get('status_emoji', '❓')
        if ticket.get('is_closed', False):
            status_emoji = '✅'
        user_name = ticket.get('user_name', 'Unknown')
        username = ticket.get('username')
        telegram_id = ticket.get('telegram_id')
        # Сформируем компактное отображение: Имя (@username | ID)
        name_parts = [user_name[:15]]
        contact_parts = []
        if username:
            contact_parts.append(f"@{username}")
        if telegram_id:
            contact_parts.append(str(telegram_id))
        if contact_parts:
            name_parts.append(f"({' | '.join(contact_parts)})")
        name_display = ' '.join(name_parts)
        title = ticket.get('title', 'Без названия')[:20]
        locked_emoji = ticket.get('locked_emoji', '')
        button_text = f"{status_emoji} #{ticket['id']} {locked_emoji} {name_display}: {title}".replace("  ", " ")
        row = [InlineKeyboardButton(text=button_text, callback_data=f"admin_view_ticket_{ticket['id']}")]
        if ticket.get('is_closed', False):
            closed_rows.append(row)
        else:
            open_rows.append(row)

    # Scope switcher
    switch_row = []
    switch_row.append(InlineKeyboardButton(text=texts.t("OPEN_TICKETS", "🔴 Открытые"), callback_data="admin_tickets_scope_open"))
    switch_row.append(InlineKeyboardButton(text=texts.t("CLOSED_TICKETS", "🟢 Закрытые"), callback_data="admin_tickets_scope_closed"))
    keyboard.append(switch_row)

    if open_rows and scope in ("all", "open"):
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("ADMIN_CLOSE_ALL_OPEN_TICKETS", "🔒 Закрыть все открытые"),
                callback_data="admin_tickets_close_all_open"
            )
        ])
        keyboard.append([InlineKeyboardButton(text=texts.t("OPEN_TICKETS_HEADER", "Открытые тикеты"), callback_data="noop")])
        keyboard.extend(open_rows)
    if closed_rows and scope in ("all", "closed"):
        keyboard.append([InlineKeyboardButton(text=texts.t("CLOSED_TICKETS_HEADER", "Закрытые тикеты"), callback_data="noop")])
        keyboard.extend(closed_rows)
    
    # Пагинация
    if total_pages > 1:
        nav_row = []
        
        if current_page > 1:
            nav_row.append(
                InlineKeyboardButton(
                    text=texts.t("PAGINATION_PREV", "⬅️"),
                    callback_data=f"admin_tickets_page_{scope}_{current_page - 1}"
                )
            )
        
        nav_row.append(
            InlineKeyboardButton(
                text=f"{current_page}/{total_pages}",
                callback_data="current_page"
            )
        )
        
        if current_page < total_pages:
            nav_row.append(
                InlineKeyboardButton(
                    text=texts.t("PAGINATION_NEXT", "➡️"),
                    callback_data=f"admin_tickets_page_{scope}_{current_page + 1}"
                )
            )
        
        keyboard.append(nav_row)
    
    keyboard.append([
        InlineKeyboardButton(text=texts.BACK, callback_data=back_callback)
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)


def get_admin_ticket_view_keyboard(
    ticket_id: int,
    is_closed: bool = False,
    language: str = DEFAULT_LANGUAGE,
    *,
    is_user_blocked: bool = False
) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    keyboard = []
    
    if not is_closed:
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("REPLY_TO_TICKET", "💬 Ответить"),
                callback_data=f"admin_reply_ticket_{ticket_id}"
            )
        ])
    
    if not is_closed:
        keyboard.append([
            InlineKeyboardButton(
                text=texts.t("CLOSE_TICKET", "🔒 Закрыть тикет"),
                callback_data=f"admin_close_ticket_{ticket_id}"
            )
        ])
    
    # Блок-контролы: когда не заблокирован — показать два варианта, когда заблокирован — только "Разблокировать"
    if is_user_blocked:
        keyboard.append([
            InlineKeyboardButton(text=texts.t("UNBLOCK", "✅ Разблокировать"), callback_data=f"admin_unblock_user_ticket_{ticket_id}")
        ])
    else:
        keyboard.append([
            InlineKeyboardButton(text=texts.t("BLOCK_FOREVER", "🚫 Заблокировать"), callback_data=f"admin_block_user_perm_ticket_{ticket_id}"),
            InlineKeyboardButton(text=texts.t("BLOCK_BY_TIME", "⏳ Блок по времени"), callback_data=f"admin_block_user_ticket_{ticket_id}")
        ])
    
    keyboard.append([
        InlineKeyboardButton(text=texts.BACK, callback_data="admin_tickets")
    ])
    
    return InlineKeyboardMarkup(inline_keyboard=keyboard)


def get_admin_ticket_reply_cancel_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
    texts = get_texts(language)
    return InlineKeyboardMarkup(inline_keyboard=[
        [
            InlineKeyboardButton(
                text=texts.t("CANCEL_REPLY", "❌ Отменить ответ"),
                callback_data="cancel_admin_ticket_reply"
            )
        ]
    ])