main.py

"""Entry point for Gif bot."""

import asyncio
import logging

from telegram import InlineQueryResultArticle, InputTextMessageContent, Update
from telegram.ext import (
    AIORateLimiter,
    ApplicationBuilder,
    CallbackQueryHandler,
    CommandHandler,
    ContextTypes,
    InlineQueryHandler,
    MessageHandler,
    filters,
)

from bot.config import settings, validate_config
from bot.handlers import (
    about_handler,
    group_search_handler,
    help_handler,
    language_callback_handler,
    language_handler,
    region_callback_handler,
    safesearch_callback_handler,
    search_handler,
    settings_callback_handler,
    settings_handler,
    start_handler,
    stats_handler,
    wiki_search_handler,
)
from bot.i18n import get_translator
from bot.services.database import DatabaseService
from bot.services.search import SearchService

# Set up basic logging configuration
logging.basicConfig(
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", level=logging.INFO
)
logger = logging.getLogger(__name__)


async def inline_query_handler(
    update: Update, context: ContextTypes.DEFAULT_TYPE
) -> None:
    """Handle the inline query - Wikipedia only."""
    query = update.inline_query.query
    user = update.effective_user

    # Get translator with user's language preference
    _ = get_translator(user.id, user.language_code)

    logger.info("User %s initiated inline query: %s", user.id, query)

    if not query:
        return

    results = []
    try:
        supported_languages = ["ru", "en", "kk", "uk", "be", "ky"]

        db = DatabaseService()
        saved_lang = db.get_user_language(user.id)

        # Priority: saved language → Telegram language → default 'ru'
        if saved_lang and saved_lang in supported_languages:
            lang = saved_lang
        elif user.language_code and user.language_code in supported_languages:
            lang = user.language_code
        else:
            lang = "ru"

        # Inline mode: Wikipedia only
        search_results = SearchService.search_wikipedia(query, lang=lang)

        if not search_results:
            results.append(
                InlineQueryResultArticle(
                    id="1",
                    title=_("Ничего не найдено"),
                    input_message_content=InputTextMessageContent(
                        _("По вашему запросу ничего не найдено.")
                    ),
                )
            )
        else:
            for i, res in enumerate(search_results):
                title = res.get("title", _("Название не указано"))
                link = res.get("link", "")
                snippet = res.get("snippet", _("Описание недоступно"))

                message_text = f"<b>{title}</b>\n\n{snippet}\n\n{link}"

                results.append(
                    InlineQueryResultArticle(
                        id=str(i),
                        title=title,
                        input_message_content=InputTextMessageContent(
                            message_text, parse_mode="HTML"
                        ),
                        description=snippet,
                    )
                )

    except Exception as e:
        logger.error(
            "Error during inline search for query '%s' by user %s: %s",
            query,
            user.id,
            e,
            exc_info=True,
        )
        results.append(
            InlineQueryResultArticle(
                id="error",
                title=_("Ошибка поиска"),
                input_message_content=InputTextMessageContent(
                    _("Произошла ошибка при поиске. Пожалуйста, попробуйте позже.")
                ),
            )
        )

    await update.inline_query.answer(results, cache_time=300)


def main():
    """Start the bot."""
    # Validate configuration
    validate_config()

    # Create application
    rate_limiter = AIORateLimiter(
        overall_max_rate=settings.rate_limit_requests,
        overall_time_period=settings.rate_limit_window,
    )
    logger.info(
        "Rate limiter configured: %d requests per %d seconds.",
        settings.rate_limit_requests,
        settings.rate_limit_window,
    )

    app = (
        ApplicationBuilder()
        .token(settings.bot_token.get_secret_value())
        .rate_limiter(rate_limiter)
        .build()
    )

    # Register command handlers
    app.add_handler(CommandHandler("start", start_handler))
    app.add_handler(CommandHandler("help", help_handler))
    app.add_handler(CommandHandler("about", about_handler))
    app.add_handler(CommandHandler("stats", stats_handler))
    app.add_handler(CommandHandler("settings", settings_handler))
    app.add_handler(CommandHandler("language", language_handler))
    app.add_handler(CommandHandler("g", group_search_handler))

    # Callback query handlers
    app.add_handler(
        CallbackQueryHandler(settings_callback_handler, pattern="^settings_")
    )
    app.add_handler(CallbackQueryHandler(language_callback_handler, pattern="^lang_"))
    app.add_handler(
        CallbackQueryHandler(safesearch_callback_handler, pattern="^safesearch_")
    )
    app.add_handler(CallbackQueryHandler(region_callback_handler, pattern="^region_"))

    # Wikipedia search handler (higher priority than regular search)
    app.add_handler(MessageHandler(filters.Regex(r"^!w\s+.+"), wiki_search_handler))

    # Text message handler (only for private chats)
    app.add_handler(
        MessageHandler(
            filters.TEXT & ~filters.COMMAND & filters.ChatType.PRIVATE, search_handler
        )
    )

    # Inline query handler
    app.add_handler(InlineQueryHandler(inline_query_handler))

    logger.info("🤖 Bot Gif started")
    logger.info("💬 In groups, use the /g command")
    app.run_polling()


if __name__ == "__main__":
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    main()