mod schema;
pub use schema::*;

mod callback_handler;
pub use callback_handler::*;

mod filter;
pub use filter::*;

use crate::ui::prelude::*;
use chrono::{FixedOffset};
use lazy_static::lazy_static;
use std::fmt::{self, Display, Formatter};

lazy_static! {
    static ref UTC_PLUS_3: FixedOffset =
        FixedOffset::east_opt(3 * 3600).expect("Invalid offset");
}

#[derive(BotCommands, Clone)]
#[command(rename_rule = "snake_case")]
pub enum Command {
    Support,
    Promo,
    Profile,
}

impl Display for SupportCallback {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        write!(f, "{}", serde_json::to_string(self).unwrap())
    }
}

pub async fn support_entrypoint(
    bot: Bot,
    dialogue: MasterDialogue,
    msg: Message,
    settings: HandlerSettings,
) -> HandlerResult {
    let message = "Панель поддержки\n\n💡 Введите ID пользователя для просмотра профиля и статистики";
    let ln = &settings.language;

    let buttons = vec![
        vec![t8x!(Ru, "🎫 Промокоды", ln, "menu-button")],
    ];

    let keyboard = make_keyboard_from_vec(buttons);

    bot.send_message(msg.chat.id, message)
        .reply_markup(keyboard)
        .await?;

    dialogue.update_kind(MasterStateKind::Support).await?;
    dialogue.update_support_kind(SupportStateKind::StatsReceiveUserId).await?;

    Ok(())
}

async fn show_promo_menu(
    bot: Bot,
    _dialogue: MasterDialogue,
    msg: Message,
    settings: HandlerSettings,
) -> HandlerResult {
    let message = "🎫 <b>Управление промокодами</b>\n\nВыберите действие:";
    let ln = &settings.language;

    let buttons = vec![
        vec![t8x!(Ru, "🎫Создать для Траффика", ln, "menu-button")],
        vec![t8x!(Ru, "🗑️Удалить промокоды",    ln, "menu-button")],
        vec![t8x!(Ru, "🔙 Назад в панель",      ln, "menu-button")],
    ];

    let keyboard = make_keyboard_from_vec(buttons);

    bot.send_message(msg.chat.id, message)
        .parse_mode(teloxide::types::ParseMode::Html)
        .reply_markup(keyboard)
        .await?;

    Ok(())
}

async fn delete_promos_handler(
    bot: Bot,
    dialogue: MasterDialogue,
    update: Update,
    msg: Message,
) -> HandlerResult {
    show_delete_promos_page(bot, dialogue, msg, update, 0).await?;
    Ok(())
}

/// Support promo handler - clean and simple
pub async fn support_promo_handler(
    bot: Bot,
    msg: Message,
    dialogue: MasterDialogue,
) -> HandlerResult {
    let config = support_promo_config();
    promo_handler_with_config(bot, msg, dialogue, config).await
}

/// Support profile handler - shows user profile without editing capabilities
pub async fn support_profile_handler(
    bot: Bot,
    dialogue: MasterDialogue,
    msg: Message,
) -> HandlerResult {
    let text = msg.text().unwrap_or("");
    
    if text.starts_with("/profile") {
        let args: Vec<&str> = text.split_whitespace().collect();
        if args.len() != 2 {
            show_support_profile_help_message(bot, msg).await?;
            return Ok(());
        }
        
        let user_id = args[1];
        show_user_profile(bot, dialogue, msg.clone(), user_id).await?;
    } else {
        let user_id = text.trim();
        if user_id.is_empty() {
            show_support_profile_help_message(bot, msg).await?;
            return Ok(());
        }
        
        show_user_profile(bot, dialogue, msg.clone(), user_id).await?;
    }

    Ok(())
}

async fn show_user_profile(
    bot: Bot,
    dialogue: MasterDialogue,
    msg: Message,
    user_id: &str,
) -> HandlerResult {
    bot.send_message(msg.chat.id, "⏳ Загрузка профиля пользователя...")
        .await?;

    match api::get_profile_with_optional_headers(user_id.to_string(), Some(user_id.to_string()), Some(user_id.to_string())).await {
        Ok(profile) => {
            let user_id = profile.id.clone();
            dialogue.update_support_kind(SupportStateKind::StatsReceiveUserId).await?;

            let personal_referral_percent = profile.personal_referral_percent.clone().unwrap_or("не указан".to_string());
            let mut message = format!(
                indoc!(
                    "
                    👤 <b>Профиль пользователя</b>
                    
                    <b>🆔 ID:</b> {id}
                    <b>👤 Имя пользователя:</b> {username}
                    <b>🛒 Количество покупок:</b> {purchases}
                    <b>🛒 Количество ГБ куплено:</b> {purchase_sum_gb}
                    <b>💰 Реферальный баланс:</b> {referral_balance:.2}
                    <b>💰 Реферальный процент:</b> {personal_referral_percent}
                    
                    <b>💾 Остатки по пулам:</b>
                    "
                ),
                id = user_id,
                username = profile.username.as_deref().unwrap_or("Не указано"),
                purchases = profile.purchase_count,
                purchase_sum_gb = profile.purchase_sum_gb,
                referral_balance = profile.referral_balance,
                personal_referral_percent = personal_referral_percent,
            );

            for pool_type in PoolType::all() {
                let pool_info = profile.get_pool_or_default(&pool_type);
                let pool_name = pool_type.display_name(&Language::Ru);
                message.push_str(&format!(
                    "  • {}: {}\n",
                    pool_name,
                    pool_info.balance_format
                ));
            }

            let pools = profile.pools.keys().cloned().collect::<Vec<_>>();

            let mut keyboard = InlineKeyboardMarkup::default();
            
            keyboard = keyboard.append_row(vec![
                InlineKeyboardButton::callback(
                    "📅 Нед. статистика",
                    SupportCallback::UserWeeklyStatsPoolChoice {
                        user_id: user_id.clone(),
                        pools: pools.iter().map(|p| (*p).into()).collect(),
                    }.to_string(),
                ),
                InlineKeyboardButton::callback(
                    "📅 Мес. статистика",
                    SupportCallback::UserMonthlyStatsPoolChoice {
                        user_id: user_id.clone(),
                        pools: pools.iter().map(|p| (*p).into()).collect(),
                    }.to_string(),
                ),
            ]);
            
            keyboard = keyboard.append_row(vec![
                InlineKeyboardButton::callback(
                    "🔙 Назад",
                    SupportCallback::AdminMenu.to_string(),
                )
            ]);

            bot.send_message(msg.chat.id, message)
                .parse_mode(teloxide::types::ParseMode::Html)
                .reply_markup(keyboard)
                .await?;
        }
        Err(e) => {
            bot.send_message(
                msg.chat.id,
                format!("❌ Ошибка загрузки профиля: {}", e),
            )
            .await?;
        }
    }

    Ok(())
}

async fn show_support_profile_help_message(bot: Bot, msg: Message) -> HandlerResult {
    let profile_help_message = indoc!(
        r#"
        ❓ Использование команды <code>/profile</code>:
        
        <code>/profile &lt;user_id&gt;</code> - показать профиль пользователя
        
        <b>Примеры:</b>
        <code>/profile 12345</code> - показать профиль пользователя с ID 12345
        <code>/profile user123</code> - показать профиль пользователя с ID user123
        
        💡 <i>Команда покажет детальную информацию о пользователе, включая балансы по пулам, статистику покупок и реферальную информацию (только для просмотра)</i>
        "#
    );

    bot.send_message(msg.chat.id, profile_help_message)
        .parse_mode(teloxide::types::ParseMode::Html)
        .await?;
    
    Ok(())
}

/// Support promo creation handler
pub async fn support_promo_create_handler(
    bot: Bot,
    dialogue: MasterDialogue,
    msg: Message,
    selected_pool: PoolType,
) -> HandlerResult {
    promo_create_handler_with_config(bot, dialogue, msg, selected_pool, PromoCreateConfig::Support).await
}

async fn show_delete_promos_page(
    bot: Bot,
    dialogue: MasterDialogue,
    msg: Message,
    update: Update,
    page: usize,
) -> HandlerResult {
    bot.send_message(msg.chat.id, "⏳ Загрузка промокодов...")
        .await?;

    match api::get_promo_codes(page, PROMOS_PER_PAGE, update.from().unwrap().id.0 as i64).await {
        Ok(promo_codes) => {
            if promo_codes.is_empty() && page == 0 {
                bot.send_message(msg.chat.id, "📭 Промокоды не найдены")
                    .reply_markup(make_inline_keyboard(
                        vec![("🔙 Вернуться в меню", SupportCallback::AdminMenu)
                            .into()],
                        1,
                    ))
                    .await?;
                return Ok(());
            }

            let message = format_promo_list_message(&promo_codes, page);
            let keyboard = make_delete_promos_keyboard(&promo_codes, page);

            bot.send_message(msg.chat.id, message)
                .reply_markup(keyboard)
                .await?;

            dialogue.update_support_kind(SupportStateKind::DeletePromos { page }).await?;
        }
        Err(e) => {
            bot.send_message(
                msg.chat.id,
                format!("❌ Ошибка загрузки промокодов: {}", e),
            )
            .reply_markup(make_inline_keyboard(
                vec![("🔙 Вернуться в меню", SupportCallback::AdminMenu).into()],
                1,
            ))
            .await?;
        }
    }

    Ok(())
}

fn make_delete_promos_keyboard(
    promo_codes: &[PromoCode],
    page: usize,
) -> InlineKeyboardMarkup {
    let mut keyboard = InlineKeyboardMarkup::default();

    for chunk in promo_codes.chunks(2) {
        let mut row = Vec::new();
        for promo in chunk {
            let button_text = format!("🗑️ {}", promo.promo_name);
            row.push(InlineKeyboardButton::callback(
                button_text,
                SupportCallback::DeletePromo {
                    promo_name: promo.promo_name.clone(),
                }
                .to_string(),
            ));
        }
        keyboard = keyboard.append_row(row);
    }

    let mut nav_buttons = Vec::new();

    if page > 0 {
        nav_buttons.push(InlineKeyboardButton::callback(
            "⬅️ Предыдущая",
            SupportCallback::DeletePromosPage { page: page - 1 }.to_string(),
        ));
    }

    if promo_codes.len() == PROMOS_PER_PAGE {
        nav_buttons.push(InlineKeyboardButton::callback(
            "Следующая ➡️",
            SupportCallback::DeletePromosPage { page: page + 1 }.to_string(),
        ));
    }

    if !nav_buttons.is_empty() {
        keyboard = keyboard.append_row(nav_buttons);
    }

    keyboard = keyboard.append_row(vec![InlineKeyboardButton::callback(
        "🔙 Вернуться в меню",
        SupportCallback::AdminMenu.to_string(),
    )]);

    keyboard
}

async fn delete_promos_state_handler(
    _bot: Bot,
    _msg: Message,
    _dialogue: MasterDialogue,
) -> HandlerResult {
    Ok(())
}

async fn handle_delete_promos_page(
    bot: Bot,
    dialogue: MasterDialogue,
    msg: Message,
    update: Update,
    page: usize,
) -> HandlerResult {
    match api::get_promo_codes(page, PROMOS_PER_PAGE, update.from().unwrap().id.0 as i64).await {
        Ok(promo_codes) => {
            if promo_codes.is_empty() {
                bot.edit_message_text(
                    msg.chat.id,
                    msg.id,
                    "📭 На этой странице промокодов нет",
                )
                .reply_markup(make_inline_keyboard(
                    vec![("🔙 Вернуться в меню", SupportCallback::AdminMenu)
                        .into()],
                    1,
                ))
                .await?;
                return Ok(());
            }

            let message = format_promo_list_message(&promo_codes, page);
            let keyboard = make_delete_promos_keyboard(&promo_codes, page);

            bot.edit_message_text(msg.chat.id, msg.id, message)
                .reply_markup(keyboard)
                .await?;

            dialogue.update_support_kind(SupportStateKind::DeletePromos { page }).await?;
        }
        Err(e) => {
            bot.edit_message_text(
                msg.chat.id,
                msg.id,
                format!("❌ Ошибка загрузки промокодов: {}", e),
            )
            .reply_markup(make_inline_keyboard(
                vec![("🔙 Вернуться в меню", SupportCallback::AdminMenu).into()],
                1,
            ))
            .await?;
        }
    }

    Ok(())
}

async fn handle_delete_promo_confirmation(
    bot: Bot,
    msg: Message,
    promo_name: String,
) -> HandlerResult {
    let message = format!(
        indoc! {r#"
            ⚠️ <b>Подтверждение удаления</b>
            
            Вы действительно хотите удалить промокод <b>{}</b>?
            
            ❗ Это действие необратимо!
        "#},
        promo_name
    );

    let buttons = vec![
        (
            "✅ Да, удалить",
            SupportCallback::ConfirmDeletePromo {
                promo_name: promo_name.clone(),
            },
        )
            .into(),
        ("❌ Отмена", SupportCallback::DeletePromosPage { page: 0 }).into(),
    ];

    let keyboard = make_inline_keyboard(buttons, 2);

    bot.edit_message_text(msg.chat.id, msg.id, message)
        .reply_markup(keyboard)
        .await?;

    Ok(())
}

async fn handle_confirm_delete_promo(
    bot: Bot,
    _dialogue: MasterDialogue,
    msg: Message,
    promo_name: String,
) -> HandlerResult {
    bot.edit_message_text(
        msg.chat.id,
        msg.id,
        format!("⏳ Удаление промокода {}...", promo_name),
    )
    .await?;

    match api::delete_promo_code(promo_name.clone()).await {
        Ok(_) => {
            bot.edit_message_text(
                msg.chat.id,
                msg.id,
                format!("✅ Промокод <b>{}</b> успешно удален!", promo_name),
            )
            .reply_markup(make_inline_keyboard(
                vec![
                    (
                        "🗑️ Удалить еще",
                        SupportCallback::DeletePromosPage { page: 0 },
                    )
                        .into(),
                    ("🔙 Вернуться в меню", SupportCallback::AdminMenu).into(),
                ],
                2,
            ))
            .await?;
        }
        Err(e) => {
            bot.edit_message_text(
                msg.chat.id,
                msg.id,
                format!("❌ Ошибка удаления промокода {}: {}", promo_name, e),
            )
            .reply_markup(make_inline_keyboard(
                vec![
                    (
                        "🔄 Попробовать снова",
                        SupportCallback::DeletePromo { promo_name },
                    )
                        .into(),
                    ("🔙 Вернуться в меню", SupportCallback::AdminMenu).into(),
                ],
                2,
            ))
            .await?;
        }
    }

    Ok(())
}

async fn handle_user_detailed_stats(
    bot: Bot,
    msg: Message,
    user_id: String,
    pool: PoolType,
    period: &str,
) -> HandlerResult {
    log::trace!("{}", format!("handle_user_detailed_stats: user_id: {}, pool: {}, period: {}", user_id, pool, period).bright_black());
    
    bot.edit_message_text(
        msg.chat.id,
        msg.id,
        format!("⏳ Загрузка {} статистики для пользователя {}...", 
                if period == "week" { "недельной" } else { "месячной" }, 
                user_id),
    )
    .await?;

    match api::get_detailed_user_stats(
        user_id.clone(),
        pool.to_string(),
        period.to_string(),
        Some(10000), // Large limit to get all data
        Some(0),     // Start from beginning
        Some("minute".to_string()), // Minute-level aggregation
    )
    .await
    {
        Ok(stats) => {
            let json_content = serde_json::to_string_pretty(&stats)
                .map_err(|e| format!("Failed to serialize stats to JSON: {}", e))?;

            let pool_name = pool.display_name(&Language::Ru);
            let filename = format!(
                "user_{}_{}_{}_stats_{}.json",
                user_id,
                pool.to_string().to_lowercase(),
                period,
                chrono::Utc::now().format("%Y%m%d_%H%M%S")
            );

            let success_message = format!(
                indoc!{r#"
                    📊 <b>{period} статистика пользователя {user_id}</b>
                    
                    <b>Пул:</b> {pool_name}
                    <b>Период:</b> {period_name}
                    <b>Общее количество записей:</b> {total_count}
                    <b>Записей в файле:</b> {len}
                    
                    📁 JSON файл отправлен отдельным сообщением
                "#},
                period = if period == "week" { "Недельная" } else { "Месячная" },
                user_id = user_id.clone(),
                pool_name = pool_name.clone(),
                period_name = if period == "week" { "последняя неделя" } else { "последний месяц" },
                total_count = stats.total_count,
                len = stats.usage.len()
            );

            log::debug!("success_message: {}", success_message);

            bot.edit_message_text(msg.chat.id, msg.id, success_message)
                .reply_markup(make_inline_keyboard(
                    vec![("🔙 Вернуться в меню", SupportCallback::AdminMenu).into()],
                    1,
                ))
                .await?;

            let file = teloxide::types::InputFile::memory(json_content.into_bytes())
                .file_name(filename);

            let caption = format!(indoc! {r#"
                    📊 Детальная статистика:
                    • Пользователь: {}
                    • Пул: {}
                    • Период: {}
                    • Записей: {}
                "#},
                user_id,
                pool_name,
                if period == "week" { "неделя" } else { "месяц" },
                stats.usage.len()
            );

            log::debug!("caption: {}", caption);

            bot.send_document(msg.chat.id, file)
                .caption(&caption)
                .await?;
        }
        Err(e) => {
            log::error!("handle_user_detailed_stats: error: {}", e);

            let error_message = "❌ Ошибка загрузки статистики".to_string();

            bot.edit_message_text(msg.chat.id, msg.id, error_message)
                .reply_markup(make_inline_keyboard(
                    vec![("🔙 Вернуться в меню", SupportCallback::AdminMenu).into()],
                    1,
                ))
                .await?;
        }
    }

    Ok(())
}

async fn add_traffic_receive_amount_handler(
    bot: Bot,
    dialogue: MasterDialogue,
    msg: Message,
    amount: String,
    _settings: HandlerSettings,
) -> HandlerResult {
    let traffic_text = amount.trim();

    let Some(state) = dialogue.get().await? else {
        bot.send_message(msg.chat.id, "❌ Ошибка получения состояния").await?;
        return Err("State not found".into());
    };

    let MasterState { support_kind: SupportStateKind::AddTrafficReceiveAmount { user_id, pool }, .. } = state else {
        bot.send_message(msg.chat.id, "❌ Ошибка получения состояния").await?;
        return Err("State not found".into());
    };
    
    let traffic_gb = match traffic_text.parse::<i32>() {
        Ok(gb) if gb > 0 && gb <= 10000 => gb,
        Ok(_) => {
            bot.send_message(
                msg.chat.id,
                "❌ Количество трафика должно быть от 1 до 10000 ГБ"
            )
            .reply_markup(make_inline_keyboard(
                vec![("🔙 Отмена", SupportCallback::AdminMenu).into()],
                1,
            ))
            .await?;
            return Ok(());
        }
        Err(_) => {
            bot.send_message(
                msg.chat.id,
                "❌ Введите корректное число ГБ трафика"
            )
            .reply_markup(make_inline_keyboard(
                vec![("🔙 Отмена", SupportCallback::AdminMenu).into()],
                1,
            ))
            .await?;
            return Ok(());
        }
    };
    
    let loading_msg = bot.send_message(
        msg.chat.id,
        format!("⏳ Добавление {} ГБ трафика пользователю {}...", traffic_gb, user_id)
    )
    .await?;
    
    match api::add_traffic_to_user(user_id.clone(), traffic_gb, pool.to_string()).await {
        Ok(response) => {
            let success_message = format!(
                indoc! {r#"
                    ✅ <b>Трафик успешно добавлен!</b>
                    
                    <b>Пользователь:</b> <code>{}</code>
                    <b>Пул:</b> <code>{}</code>
                    <b>Добавлено трафика:</b> <code>{} ГБ</code>
                    <b>Баланс до добавления:</b> <code>{}</code>
                    <b>ID сабюзера:</b> <code>{}</code>
                "#},
                response.user_id,
                response.pool,
                response.traffic_added_gb,
                response.balance_before,
                response.subuser_id
            );
            
            bot.edit_message_text(loading_msg.chat.id, loading_msg.id, success_message)
                .parse_mode(teloxide::types::ParseMode::Html)
                .reply_markup(make_inline_keyboard(
                    vec![("🔙 Вернуться в меню", SupportCallback::AdminMenu).into()],
                    1,
                ))
                .await?;
        }
        Err(e) => {
            let error_message = format!(
                "❌ <b>Ошибка добавления трафика</b>\n\n<b>Пользователь:</b> <code>{}</code>\n<b>Ошибка:</b> <code>{}</code>",
                user_id, e
            );
            
            bot.edit_message_text(loading_msg.chat.id, loading_msg.id, error_message)
                .parse_mode(teloxide::types::ParseMode::Html)
                .reply_markup(make_inline_keyboard(
                    vec![
                        ("🔄 Попробовать снова", SupportCallback::AddTraffic { 
                            user_id: user_id.clone(), 
                            pool: Some(pool) 
                        }).into(),
                        ("🔙 Вернуться в меню", SupportCallback::AdminMenu).into()
                    ],
                    1,
                ))
                .await?;
        }
    }
    
    dialogue.update_support_kind(SupportStateKind::Menu).await?;
    Ok(())
}

async fn handle_change_price_pool(
    bot: Bot,
    dialogue: MasterDialogue,
    msg: Message,
    pool_type: PoolType,
) -> HandlerResult {
    let current_price = match api::get_current_price(pool_type).await {
        Ok(price) => format!(" (текущая цена: ${:.2})", price),
        Err(_) => String::new(),
    };

    let message_text = format!(
        "💰 <b>Изменение цены для пула {}</b>\n\n📋 Введите новую стоимость за гигабайт в USD{}:",
        pool_type_to_display_name(&pool_type),
        current_price
    );

    bot.edit_message_text(msg.chat.id, msg.id, message_text)
        .parse_mode(teloxide::types::ParseMode::Html)
        .reply_markup(make_inline_keyboard(
            vec![("🔙 Отмена", SupportCallback::AdminMenu).into()],
            1,
        ))
        .await?;

    dialogue
        .update_support_kind(SupportStateKind::ReceivePoolPrice { pool_type })
        .await?;

    Ok(())
}

async fn receive_pool_price_handler(
    bot: Bot,
    msg: Message,
    dialogue: MasterDialogue,
    pool_type: PoolType,
) -> HandlerResult {
    if let Some(text) = msg.text() {
        match text.parse::<f64>() {
            Ok(new_price) => {
                if new_price <= 0.0 {
                    bot.send_message(msg.chat.id, "❌ Цена должна быть положительным числом. Попробуйте еще раз:")
                        .await?;
                    return Ok(());
                }

                if new_price > 1000.0 {
                    bot.send_message(msg.chat.id, "❌ Цена слишком высокая. Максимальная цена: $1000. Попробуйте еще раз:")
                        .await?;
                    return Ok(());
                }

                let user_id = msg.from.unwrap().id.0 as i64;
                let pool_string = pool_type_to_string(&pool_type);

                log::info!(
                    "Admin {} attempting to update price for pool '{}' to ${:.2}",
                    user_id,
                    pool_string,
                    new_price
                );

                match api::update_pool_price(pool_string, new_price, user_id).await {
                    Ok(()) => {
                        bot.send_message(
                            msg.chat.id,
                            format!(
                                "✅ Успешно! Стоимость пула {} обновлена на ${:.2} за гигабайт",
                                pool_type_to_display_name(&pool_type),
                                new_price
                            ),
                        )
                        .await?;

                        log::info!(
                            "Admin {} changed price for pool {} to ${:.2}",
                            user_id,
                            pool_type_to_string(&pool_type),
                            new_price
                        );

                        dialogue.update_support_kind(SupportStateKind::Menu).await?;
                    }
                    Err(e) => {
                        log::error!(
                            "Failed to update price for pool '{}' to ${:.2} by admin {}: {}",
                            pool_type_to_string(&pool_type),
                            new_price,
                            user_id,
                            e
                        );
                        
                        bot.send_message(
                            msg.chat.id,
                            format!("❌ Ошибка при обновлении цены: {}", e),
                        )
                        .await?;
                    }
                }
            }
            Err(_) => {
                bot.send_message(
                    msg.chat.id,
                    "❌ Неверный формат цены. Введите число (например: 2.5):",
                )
                .await?;
            }
        }
    }

    Ok(())
}

fn pool_type_to_display_name(pool_type: &PoolType) -> &'static str {
    match pool_type {
        PoolType::Residential => "🖥 Residential",
        PoolType::ResidentialPremium => "🖥 Residential Premium",
        PoolType::Mobile => "📱 Mobile",
        PoolType::Datacenter => "📺 Datacenter",
    }
}

fn pool_type_to_string(pool_type: &PoolType) -> String {
    match pool_type {
        PoolType::Residential => "residential".to_string(),
        PoolType::ResidentialPremium => "residential_premium".to_string(),
        PoolType::Mobile => "mobile".to_string(),
        PoolType::Datacenter => "datacenter".to_string(),
    }
}

async fn handle_drop_balance_confirmation(
    bot: Bot,
    msg: Message,
    user_id: String,
    pool: PoolType,
) -> HandlerResult {
    let confirmation_message = format!(
        indoc! {r#"
            ⚠️ <b>Подтверждение сброса баланса</b>
            
            <b>Пользователь:</b> <code>{}</code>
            <b>Пул:</b> <code>{}</code>
            
            ❗️ <b>ВНИМАНИЕ!</b> Это действие удалит весь трафик пользователя в выбранном пуле без возможности восстановления.
            
            Вы уверены, что хотите продолжить?
        "#},
        user_id,
        pool_type_to_display_name(&pool)
    );

    let keyboard = make_inline_keyboard(
        vec![
            (
                "✅ Да, сбросить баланс",
                SupportCallback::ConfirmDropBalance {
                    user_id: user_id.clone(),
                    pool,
                },
            ).into(),
            ("❌ Отмена", SupportCallback::AdminMenu).into(),
        ],
        1,
    );

    bot.edit_message_text(msg.chat.id, msg.id, confirmation_message)
        .parse_mode(teloxide::types::ParseMode::Html)
        .reply_markup(keyboard)
        .await?;

    Ok(())
}

async fn handle_confirm_drop_balance(
    bot: Bot,
    dialogue: MasterDialogue,
    msg: Message,
    user_id: String,
    pool: PoolType,
) -> HandlerResult {
    let loading_msg = bot.edit_message_text(
        msg.chat.id,
        msg.id,
        format!(
            "⏳ <b>Сброс баланса пользователя...</b>\n\n<b>Пользователь:</b> <code>{}</code>\n<b>Пул:</b> <code>{}</code>",
            user_id,
            pool_type_to_display_name(&pool)
        )
    )
    .parse_mode(teloxide::types::ParseMode::Html)
    .await?;

    match api::drop_balance_user(user_id.clone(), pool_type_to_string(&pool)).await {
        Ok(()) => {
            let success_message = format!(
                indoc! {r#"
                    ✅ <b>Баланс успешно сброшен!</b>
                    
                    <b>Пользователь:</b> <code>{}</code>
                    <b>Пул:</b> <code>{}</code>
                    
                    Весь трафик в данном пуле удален.
                "#},
                user_id,
                pool_type_to_display_name(&pool)
            );
            
            bot.edit_message_text(loading_msg.chat.id, loading_msg.id, success_message)
                .parse_mode(teloxide::types::ParseMode::Html)
                .reply_markup(make_inline_keyboard(
                    vec![("🔙 Вернуться в меню", SupportCallback::AdminMenu).into()],
                    1,
                ))
                .await?;
        }
        Err(e) => {
            let error_message = format!(
                "❌ <b>Ошибка сброса баланса</b>\n\n<b>Пользователь:</b> <code>{}</code>\n<b>Пул:</b> <code>{}</code>\n<b>Ошибка:</b> <code>{}</code>",
                user_id,
                pool_type_to_display_name(&pool),
                e
            );
            
            bot.edit_message_text(loading_msg.chat.id, loading_msg.id, error_message)
                .parse_mode(teloxide::types::ParseMode::Html)
                .reply_markup(make_inline_keyboard(
                    vec![
                        ("🔄 Попробовать снова", SupportCallback::DropBalance { 
                            user_id: user_id.clone(), 
                            pool: Some(pool) 
                        }).into(),
                        ("🔙 Вернуться в меню", SupportCallback::AdminMenu).into()
                    ],
                    1,
                ))
                .await?;
        }
    }
    
    dialogue.update_support_kind(SupportStateKind::Menu).await?;
    Ok(())
}
