from aiogram import Router, F
from aiogram.filters import Command
from aiogram.types import Message, CallbackQuery, InlineKeyboardMarkup, InlineKeyboardButton

from config.settings import settings
from database.db import async_session_maker
from database.models import AIProvider
from services.ai_model_service import AIModelService

router = Router()


def get_admin_ids() -> set:
    """Получить множество ID админов"""
    if not settings.admin_ids:
        return set()
    return set(int(x.strip()) for x in settings.admin_ids.split(",") if x.strip())


def is_admin(user_id: int) -> bool:
    """Проверить, является ли пользователь админом"""
    return user_id in get_admin_ids()


async def get_model_keyboard() -> InlineKeyboardMarkup:
    """Создать клавиатуру выбора AI модели"""
    async with async_session_maker() as session:
        models = await AIModelService.get_all_models(session)

    keyboard = []
    for model in models:
        marker = "✓ " if model.is_active else ""
        provider_emoji = "🟢" if model.provider == AIProvider.openai else "🔵"
        keyboard.append([InlineKeyboardButton(
            text=f"{marker}{provider_emoji} {model.display_name}",
            callback_data=f"admin_model_{model.id}"
        )])

    keyboard.append([InlineKeyboardButton(text="❌ Закрыть", callback_data="admin_close")])
    return InlineKeyboardMarkup(inline_keyboard=keyboard)


@router.message(Command("admin"))
async def cmd_admin(message: Message):
    """Админская панель"""
    if not is_admin(message.from_user.id):
        return

    # Убеждаемся что дефолтные модели созданы
    async with async_session_maker() as session:
        await AIModelService.ensure_default_models(session)
        active_model = await AIModelService.get_active_model(session)

    active_name = active_model.display_name if active_model else "Не выбрана"

    text = (
        "🔧 <b>Админ-панель</b>\n\n"
        f"🤖 Текущая AI модель: <b>{active_name}</b>\n\n"
        "Выберите модель для генерации:"
    )

    keyboard = await get_model_keyboard()
    await message.answer(text, reply_markup=keyboard)


@router.callback_query(F.data.startswith("admin_model_"))
async def set_admin_model(callback: CallbackQuery):
    """Установить AI модель"""
    if not is_admin(callback.from_user.id):
        await callback.answer("⛔ Доступ запрещен", show_alert=True)
        return

    model_id = int(callback.data.split("_")[-1])

    async with async_session_maker() as session:
        success = await AIModelService.set_active_model(session, model_id)

        if success:
            active_model = await AIModelService.get_active_model(session)
            await callback.answer(f"✅ Модель изменена: {active_model.display_name}")

            text = (
                "🔧 <b>Админ-панель</b>\n\n"
                f"🤖 Текущая AI модель: <b>{active_model.display_name}</b>\n\n"
                "Выберите модель для генерации:"
            )
        else:
            await callback.answer("❌ Ошибка при смене модели", show_alert=True)
            text = "🔧 <b>Админ-панель</b>\n\n❌ Ошибка при смене модели"

    keyboard = await get_model_keyboard()
    await callback.message.edit_text(text, reply_markup=keyboard)


@router.callback_query(F.data == "admin_close")
async def admin_close(callback: CallbackQuery):
    """Закрыть админ-панель"""
    if not is_admin(callback.from_user.id):
        return

    await callback.message.delete()
    await callback.answer()


@router.message(Command("generate_wod"))
async def cmd_generate_wod(message: Message):
    """Принудительная генерация слов дня"""
    if not is_admin(message.from_user.id):
        return

    from services.wordofday_service import wordofday_service

    await message.answer("⏳ Запускаю генерацию слов дня...")

    try:
        results = await wordofday_service.generate_all_words_for_today()
        total = results.get("en", 0) + results.get("ja", 0)
        errors = results.get("errors", 0)

        text = (
            "✅ <b>Генерация завершена</b>\n\n"
            f"📊 Всего сгенерировано: {total}\n"
            f"🇬🇧 Английский: {results.get('en', 0)}\n"
            f"🇯🇵 Японский: {results.get('ja', 0)}\n"
            f"❌ Ошибок: {errors}"
        )
    except Exception as e:
        text = f"❌ Ошибка генерации: {e}"

    await message.answer(text)