bot.py

"""Travel Bot - Telegram бот для турагента"""
import os
from dotenv import load_dotenv
from aiogram import Bot, Dispatcher, types, F
from aiogram.filters import Command
from aiogram.enums import ParseMode
import asyncio

# Устанавливаем политику的事件 loop
asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())

from flows import (
    set_state, get_state, get_data, update_data, clear_state,
    State, TEXTS, format_country_info, format_confirm,
)
from keyboards import (
    main_keyboard, phone_keyboard, cancel_keyboard,
    countries_keyboard, country_keyboard, confirm_keyboard,
)
import supabase_client as sc
import ai

load_dotenv()

BOT_TOKEN = os.getenv("BOT_TOKEN")
ADMINS = [int(x) for x in os.getenv("ADMINS", "").split(",") if x.strip().isdigit()]

# bot и dispatcher
bot = Bot(token=BOT_TOKEN)
dp = Dispatcher()


# ==================== HANDLERS ====================

@dp.message(Command("start"))
async def cmd_start(message: types.Message):
    """Старт бота"""
    clear_state(message.from_user.id)
    await message.answer(TEXTS["start"], reply_markup=main_keyboard())


@dp.message(Command("admin"))
async def cmd_admin(message: types.Message):
    """Админ команды"""
    if message.from_user.id not in ADMINS:
        await message.answer("⛔ Нет доступа")
        return

    # Получаем заявки
    leads = await sc.get_leads(limit=10)

    if not leads:
        await message.answer("📭 Заявок пока нет")
        return

    # Формируем сообщение
    text = "📊 <b>Последние заявки:</b>\n\n"
    for lead in leads:
        name = lead.get("name", "-")
        phone = lead.get("phone", "-")
        created = lead.get("created_at", "-")[:10]
        text += f"• {name} — {phone} ({created})\n"

    await message.answer(text, parse_mode=ParseMode.HTML)


@dp.message(Command("show"))
async def cmd_show(message: types.Message):
    """Показать все заявки в красивом формате (только админы)"""
    if message.from_user.id not in ADMINS:
        await message.answer("⛔ Только для админов")
        return

    leads = await sc.get_leads(limit=50)

    if not leads:
        await message.answer("📭 Заявок пока нет")
        return

    # Формируем красивое сообщение
    text = f"📋 <b>Все заявки ({len(leads)}):</b>\n\n"

    for i, lead in enumerate(leads, 1):
        # ID
        lead_id = lead.get("id", "?")
        text += f"━━━━━━━━━━━━━━━━━━\n"
        text += f"🔹 <b>Заявка #{lead_id}</b>\n"

        # Клиент
        name = lead.get("name", "-")
        phone = lead.get("phone", "-")
        text += f"👤 <b>{name}</b> | 📞 {phone}\n"

        # Страна
        country_id = lead.get("country_id")
        if country_id:
            country = await sc.get_country_by_id(country_id)
            if country:
                flag = country.get("flag", "")
                cname = country.get("name", "")
                text += f"🌍 {flag} {cname}\n"

        # Пожелания
        wishes = lead.get("message", "")
        if wishes:
            text += f"💭 <i>{wishes}</i>\n"

        # Уточнение
        clarification = lead.get("clarification", "")
        if clarification:
            text += f"✏️ <b>Уточнение:</b> {clarification}\n"

        # Дата
        created = lead.get("created_at", "")
        if created:
            date_str = created[:10]
            time_str = created[11:16]
            text += f"📅 {date_str} {time_str}\n"

        text += "\n"

    await message.answer(text, parse_mode=ParseMode.HTML)


@dp.message(Command("showprompt"))
async def cmd_show_prompt(message: types.Message):
    """Показать текущий AI промпт (только админы)"""
    if message.from_user.id not in ADMINS:
        await message.answer("⛔ Только для админов")
        return

    current_prompt = await sc.get_ai_prompt()
    await message.answer(
        f"📝 <b>Текущий AI промпт:</b>\n\n<code>{current_prompt}</code>",
        parse_mode=ParseMode.HTML
    )


@dp.message(Command("editprompt"))
async def cmd_edit_prompt(message: types.Message):
    """Изменить AI промпт (только админы)"""
    if message.from_user.id not in ADMINS:
        await message.answer("⛔ Только для админов")
        return

    # Получаем текст после команды
    args = message.text.split(" ", 1)
    if len(args) == 1:
        await message.answer(
            "❌ Укажите новый промпт.\n"
            "💡 Используйте: <code>/editprompt Текст промпта</code>",
            parse_mode=ParseMode.HTML
        )
        return

    new_prompt = args[1].strip()
    success = await sc.update_ai_prompt(new_prompt)
    if success:
        await message.answer("✅ Промпт обновлён!")
    else:
        await message.answer("❌ Ошибка при обновлении")


@dp.message(F.text == "❌ Отмена")
async def cmd_cancel(message: types.Message):
    """Отмена текущего действия"""
    clear_state(message.from_user.id)
    await message.answer(TEXTS["cancel"], reply_markup=main_keyboard())


@dp.message(F.text == "🔍 Подобрать тур")
@dp.message(F.text == "🌍 Страны")
async def cmd_countries(message: types.Message):
    """Показать страны"""
    countries = await sc.get_countries()

    if not countries:
        await message.answer("😔 Пока нет доступных стран")
        return

    set_state(message.from_user.id, State.MENU)
    await message.answer(
        TEXTS["select_country"],
        reply_markup=countries_keyboard(countries)
    )


@dp.message(F.text == "❓ Вопрос")
async def cmd_question_start(message: types.Message):
    """Начать вопрос AI"""
    set_state(message.from_user.id, State.WAITING_QUESTION)
    await message.answer(TEXTS["ask_question"], reply_markup=cancel_keyboard())


@dp.message(F.text == "📞 Перезвоните мне")
async def cmd_callback(message: types.Message):
    """Запрос обратного звонка"""
    user_id = message.from_user.id
    state = get_state(user_id)

    # Если уже ждем телефон - не дублируем сообщение
    if state == State.WAITING_PHONE:
        await message.answer("👇 Нажмите кнопку ниже", reply_markup=phone_keyboard())
        return

    update_data(user_id, "flow", "callback")
    set_state(user_id, State.WAITING_PHONE)
    await message.answer(TEXTS["send_phone"], reply_markup=phone_keyboard())


# ==================== CALLBACK HANDLERS ====================

@dp.callback_query(F.data == "countries_list")
async def cb_countries_list(callback: types.CallbackQuery):
    """Вернуться к списку стран"""
    countries = await sc.get_countries()

    # Редактируем с обработкой ошибок
    try:
        await callback.message.edit_text(
            TEXTS["select_country"],
            reply_markup=countries_keyboard(countries)
        )
        await callback.answer()
    except Exception as e:
        print(f"Error showing countries list: {e}")
        # Если не удалось отредактировать, отправляем новое сообщение
        await callback.answer()
        await callback.message.answer(
            TEXTS["select_country"],
            reply_markup=countries_keyboard(countries)
        )


@dp.callback_query(F.data.startswith("countries_"))
async def cb_countries_page(callback: types.CallbackQuery):
    """Пагинация стран"""
    page = int(callback.data.split("_")[1])
    countries = await sc.get_countries()

    # Редактируем с обработкой ошибок
    try:
        await callback.message.edit_reply_markup(
            reply_markup=countries_keyboard(countries, page=page)
        )
        await callback.answer()
    except Exception as e:
        print(f"Error paginating countries: {e}")
        await callback.answer("⚠️ Ошибка. Попробуйте снова.")


@dp.callback_query(F.data.startswith("country_"))
async def cb_country(callback: types.CallbackQuery):
    """Показать страну"""
    country_id = int(callback.data.split("_")[1])
    country = await sc.get_country_by_id(country_id)

    if not country:
        await callback.answer("😕 Страна не найдена")
        return

    # Сохраняем выбранную страну
    update_data(callback.from_user.id, "country", country)

    # Редактируем с обработкой ошибок
    try:
        await callback.message.edit_text(
            format_country_info(country),
            parse_mode=ParseMode.HTML,
            reply_markup=country_keyboard(country_id)
        )
        await callback.answer()
    except Exception as e:
        print(f"Error showing country: {e}")
        # Если не удалось отредактировать, отправляем новое сообщение
        await callback.answer()
        await callback.message.answer(
            format_country_info(country),
            parse_mode=ParseMode.HTML,
            reply_markup=country_keyboard(country_id)
        )


@dp.callback_query(F.data.startswith("info_"))
async def cb_country_info(callback: types.CallbackQuery):
    """Узнать подробнее о стране (AI)"""
    country_id = int(callback.data.split("_")[1])
    country = await sc.get_country_by_id(country_id)

    if not country:
        await callback.answer("😕 Страна не найдена")
        return

    # Сразу отвечаем на callback чтобы не истёк
    await callback.answer("🤖 Думаю...")

    # Получаем инфу от AI
    info = await ai.get_country_info(country.get("name", ""))

    if info:
        text = format_country_info(country) + f"\n\n🤖 <b>Подробнее:</b>\n\n{info}"
    else:
        text = format_country_info(country)

    # Редактируем сообщение с обработкой ошибок
    try:
        await callback.message.edit_text(
            text,
            parse_mode=ParseMode.HTML,
            reply_markup=country_keyboard(country_id)
        )
    except Exception as e:
        print(f"Error editing message: {e}")
        # Если не удалось отредактировать (callback истёк), отправляем новое
        await callback.message.answer(
            text,
            parse_mode=ParseMode.HTML,
            reply_markup=country_keyboard(country_id)
        )


@dp.callback_query(F.data.startswith("book_"))
async def cb_book_start(callback: types.CallbackQuery):
    """Начать бронирование"""
    country_id = int(callback.data.split("_")[1])
    country = await sc.get_country_by_id(country_id)

    if country:
        update_data(callback.from_user.id, "country", country)

    set_state(callback.from_user.id, State.WAITING_PHONE)
    await callback.message.edit_text(
        TEXTS["send_phone"],
        parse_mode=ParseMode.HTML,
        reply_markup=None,
    )
    await callback.answer("📱 Отправьте номер телефона", show_alert=True)


@dp.callback_query(F.data == "change_data")
async def cb_change_data(callback: types.CallbackQuery):
    """Изменить данные"""
    set_state(callback.from_user.id, State.WAITING_WISHES)
    await callback.message.edit_text(
        TEXTS["send_wishes"],
        reply_markup=None,
    )
    await callback.answer()


@dp.callback_query(F.data.startswith("confirm_"))
async def cb_confirm(callback: types.CallbackQuery):
    """Подтвердить заявку"""
    user_id = callback.from_user.id
    data = get_data(user_id)

    # Проверяем - уже создавали заявку? (ПРОВЕРКА ПЕРЕД ЛЮБЫМИ ДЕЙСТВИЯМИ)
    if data.get("lead_created"):
        await callback.answer("ℹ️ Заявка уже создана")
        try:
            await callback.message.edit_reply_markup(reply_markup=None)
        except:
            pass
        return

    # СРАЗУ ставим флаг что заявка создаётся (блокируем повторные клики)
    update_data(user_id, "lead_created", True)

    # СРАЗУ удаляем кнопки чтобы не нажимали дважды
    try:
        await callback.message.edit_reply_markup(reply_markup=None)
    except:
        pass

    # Создаём лид в Supabase и получаем ID
    lead = await sc.create_lead(
        telegram_id=user_id,
        name=data.get("name", ""),
        phone=data.get("phone", ""),
        country_id=data.get("country", {}).get("id"),
        message=data.get("wishes", ""),
    )

    lead_id = lead.get("id") if lead else None
    update_data(user_id, "last_lead_id", lead_id)

    # Сообщение пользователю
    await callback.message.edit_text(
        TEXTS["thanks_lead"],
        reply_markup=None,
    )

    # Уведомление админам
    country_name = data.get("country", {}).get("name", "Не выбрано")
    wishes = data.get("wishes", "-")

    admin_text = (
        f"🔔 <b>НОВАЯ ЗАЯВКА!</b>\n\n"
        f"👤 {data.get('name', '')}\n"
        f"📞 {data.get('phone', '')}\n"
        f"🌍 {country_name}\n"
        f"💭 {wishes}\n"
        f"👤 Telegram ID: {user_id}"
    )

    for admin_id in ADMINS:
        try:
            await bot.send_message(admin_id, admin_text, parse_mode=ParseMode.HTML)
        except:
            pass

    await callback.answer("✅ Заявка отправлена!")

    # Проверяем нужно ли задавать уточнения
    wishes = data.get("wishes", "").lower()

    # Умная проверка на наличие информации
    import re

    # Проверка дат
    has_dates = bool(re.search(r'(\d{1,2})\s*(января|февраля|марта|апреля|мая|июня|июля|август|сентября|октября|ноября|декабря)|с\s+\d+\s+по\s+\d+', wishes))
    # Проверка людей
    has_people = bool(re.search(r'\b\d+\s*(человек|чел|чела|гост)', wishes))

    # Логика:
    # 1. Если есть даты и люди -> ничего не спрашиваем
    # 2. Если нет -> задаём один вопрос "все уточнения в одном сообщении"
    if has_dates and has_people:
        # Всё указано - просто завершаем
        clear_state(user_id)
        await callback.message.answer("✅ Спасибо! Все данные указаны. Заявка готова.")
        await callback.message.answer("Главное меню:", reply_markup=main_keyboard())
    elif data.get("country"):
        # Задаём один вопрос: "напишите все уточнения в одном сообщении"
        await callback.message.answer(
            "💭 <b>Уточните детали:</b>\n\n"
            "Напишите в ОДНОМ сообщении:\n"
            "• Точные даты (если ещё не указали)\n"
            "• Количество человек и есть ли дети\n"
            "• Что важно (тип номера, питание, активность)",
            parse_mode=ParseMode.HTML
        )
        set_state(user_id, State.WAITING_CLARIFICATION)


@dp.callback_query(F.data == "cancel_booking")
async def cb_cancel_booking(callback: types.CallbackQuery):
    """Отменить бронирование"""
    clear_state(callback.from_user.id)
    await callback.message.edit_text(
        TEXTS["cancel"],
        reply_markup=None,
    )
    await callback.answer()


@dp.callback_query(F.data == "close")
async def cb_close(callback: types.CallbackQuery):
    """Закрыть сообщение"""
    try:
        await callback.message.delete()
    except:
        pass
    await callback.answer()


@dp.callback_query(F.data.startswith("confirm_clarification_"))
async def cb_confirm_clarification(callback: types.CallbackQuery):
    """Подтвердить уточнения"""
    user_id = callback.from_user.id

    # Проверяем что это именно для этого пользователя
    callback_user_id = int(callback.data.split("_")[2])
    if callback_user_id != user_id:
        await callback.answer("⛔ Не ваша кнопка", show_alert=True)
        return

    # Получаем уточнение
    data = get_data(user_id)
    c1 = data.get("clarification_1", "")

    # Если нет уточнений - просто завершаем
    if not c1 or c1.strip() == "":
        clear_state(user_id)
        await callback.answer("✅ Готово!")
        await callback.message.edit_text("✅ Спасибо! Заявка готова. Мы свяжемся с вами в ближайшее время.")
        await callback.message.answer("Главное меню:", reply_markup=main_keyboard())
        return

    clarification = c1 if c1 else "Нет уточнений"

    # Сохраняем в Supabase
    lead_id = data.get("last_lead_id")
    if lead_id:
        success = await sc.add_clarification(lead_id, clarification)
        if success:
            await callback.message.edit_text("✅ Уточнения сохранены! Мы свяжемся с вами в ближайшее время.")
        else:
            await callback.message.edit_text("⚠️ Не удалось сохранить. Попробуйте позже.")
    else:
        await callback.message.edit_text("⚠️ Заявка не найдена.")

    clear_state(user_id)
    await callback.answer("✅ Сохранено!")
    await callback.message.answer("Главное меню:", reply_markup=main_keyboard())


# ==================== TEXT HANDLERS ====================

@dp.message(F.contact)
async def msg_phone(message: types.Message):
    """Получили телефон"""
    phone = message.contact.phone_number
    user_id = message.from_user.id

    update_data(user_id, "phone", phone)

    state = get_state(user_id)

    if state == State.WAITING_PHONE:
        set_state(user_id, State.WAITING_NAME)
        await message.answer(TEXTS["send_name"], reply_markup=cancel_keyboard())
    else:
        await message.answer("✅ Телефон получен", reply_markup=main_keyboard())


@dp.message()
async def msg_text(message: types.Message):
    """Обработка текстовых сообщений"""
    user_id = message.from_user.id
    state = get_state(user_id)
    text = message.text

    if state == State.WAITING_NAME:
        update_data(user_id, "name", text)
        set_state(user_id, State.WAITING_WISHES)
        await message.answer(TEXTS["send_wishes"], reply_markup=cancel_keyboard())

    elif state == State.WAITING_WISHES:
        update_data(user_id, "wishes", text)

        # Показываем подтверждение
        data = get_data(user_id)
        set_state(user_id, State.MENU)

        # Получаем country_id для кнопки
        country_id = data.get("country", {}).get("id", 0)

        await message.answer(
            format_confirm(data),
            parse_mode=ParseMode.HTML,
            reply_markup=confirm_keyboard(country_id)
        )

    elif state == State.WAITING_QUESTION:
        # Общие вопросы AI (визы, погода) - НЕ создают заявки
        await message.answer("🤖 Думаю...")
        answer = await ai.ask_question(text)

        if answer:
            await message.answer(answer, reply_markup=main_keyboard())
        else:
            await message.answer("😕 Не удалось получить ответ. Попробуйте позже.", reply_markup=main_keyboard())

        clear_state(user_id)

    elif state == State.WAITING_CLARIFICATION:
        # Уточнение по заявке - пользователь ответил
        update_data(user_id, "clarification_1", text)

        # Сохраняем в Supabase и показываем подтверждение
        lead_id = get_data(user_id).get("last_lead_id")
        if lead_id:
            await sc.add_clarification(lead_id, text)
            await message.answer("✅ Уточнения сохранены!")
        else:
            await message.answer("⚠️ Не удалось сохранить.")

        clear_state(user_id)
        await message.answer("Главное меню:", reply_markup=main_keyboard())

    else:
        # Неизвестная команда
        await message.answer("Выберите действие в меню 👇", reply_markup=main_keyboard())


async def _show_confirm_button(message, user_id: int):
    """Показать кнопку подтверждения уточнений"""
    from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton

    data = get_data(user_id)
    c1 = data.get("clarification_1", "")

    # Если нет уточнений - не показываем кнопку, сразу меню
    if not c1:
        await message.answer("✅ Спасибо! Заявка готова.")
        return

    text = f"✅ <b>Ваши уточнения:</b>\n\n📅 {c1}\n\nНажмите кнопку ниже чтобы подтвердить 👇"

    keyboard = InlineKeyboardMarkup(inline_keyboard=[
        [InlineKeyboardButton(text="✅ Подтвердить", callback_data=f"confirm_clarification_{user_id}")]
    ])

    set_state(user_id, State.WAITING_CONFIRM)
    await message.answer(text, parse_mode=ParseMode.HTML, reply_markup=keyboard)


# ==================== MAIN ====================

async def main():
    """Запуск бота"""
    print("🤖 Бот запущен!")
    await dp.start_polling(bot)


if __name__ == "__main__":
    asyncio.run(main())