new_lottery_bot/main.py

"""
Новая модульная версия main.py с применением SOLID принципов
"""

import asyncio
import logging
from contextlib import asynccontextmanager

from aiogram import Bot, Dispatcher, Router, F
from aiogram.types import Message, CallbackQuery
from aiogram.filters import Command
from aiogram.fsm.storage.memory import MemoryStorage

from src.core.config import BOT_TOKEN
from src.core.database import async_session_maker
from src.container import container
from src.interfaces.base import IBotController

# Настройка логирования
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

# Создание бота и диспетчера
bot = Bot(token=BOT_TOKEN)
storage = MemoryStorage()
dp = Dispatcher(storage=storage)
router = Router()


@asynccontextmanager
async def get_controller():
    """Контекстный менеджер для получения контроллера с БД сессией"""
    async with async_session_maker() as session:
        scoped_container = container.create_scoped_container(session)
        controller = scoped_container.get(IBotController)
        yield controller


# === COMMAND HANDLERS ===

@router.message(Command("start"))
async def cmd_start(message: Message):
    """Обработчик команды /start"""
    async with get_controller() as controller:
        await controller.handle_start(message)


@router.message(Command("admin"))
async def cmd_admin(message: Message):
    """Обработчик команды /admin"""
    async with get_controller() as controller:
        if not controller.is_admin(message.from_user.id):
            await message.answer("❌ Недостаточно прав для доступа к админ панели")
            return
        
        # Создаем callback query объект для совместимости
        from aiogram.types import CallbackQuery
        fake_callback = CallbackQuery(
            id="admin_cmd",
            from_user=message.from_user,
            chat_instance="admin",
            data="admin_panel",
            message=message
        )
        await controller.handle_admin_panel(fake_callback)


# === CALLBACK HANDLERS ===

@router.callback_query(F.data == "test_callback")
async def test_callback_handler(callback: CallbackQuery):
    """Тестовый callback handler"""
    await callback.answer("✅ Тест прошел успешно! Колбэки работают.", show_alert=True)


@router.callback_query(F.data == "admin_panel")
async def admin_panel_handler(callback: CallbackQuery):
    """Обработчик админ панели"""
    async with get_controller() as controller:
        await controller.handle_admin_panel(callback)


@router.callback_query(F.data == "lottery_management")
async def lottery_management_handler(callback: CallbackQuery):
    """Обработчик управления розыгрышами"""
    async with get_controller() as controller:
        await controller.handle_lottery_management(callback)


@router.callback_query(F.data == "conduct_lottery_admin")
async def conduct_lottery_admin_handler(callback: CallbackQuery):
    """Обработчик выбора розыгрыша для проведения"""
    async with get_controller() as controller:
        await controller.handle_conduct_lottery_admin(callback)


@router.callback_query(F.data == "active_lotteries")
async def active_lotteries_handler(callback: CallbackQuery):
    """Обработчик показа активных розыгрышей"""
    async with get_controller() as controller:
        await controller.handle_active_lotteries(callback)


@router.callback_query(F.data.startswith("conduct_") & ~F.data.in_(["conduct_lottery_admin"]))
async def conduct_specific_lottery_handler(callback: CallbackQuery):
    """Обработчик проведения конкретного розыгрыша"""
    async with get_controller() as controller:
        await controller.handle_conduct_lottery(callback)


@router.callback_query(F.data == "back_to_main")
async def back_to_main_handler(callback: CallbackQuery):
    """Обработчик возврата в главное меню"""
    # Имитируем команду /start
    fake_message = Message(
        message_id=callback.message.message_id,
        date=callback.message.date,
        chat=callback.message.chat,
        from_user=callback.from_user
    )
    
    async with get_controller() as controller:
        await controller.handle_start(fake_message)


# === ЗАГЛУШКИ ДЛЯ ОСТАЛЬНЫХ CALLBACKS ===

@router.callback_query(F.data.in_([
    "user_management", "account_management", "chat_management", 
    "settings", "stats", "create_lottery"
]))
async def feature_stubs(callback: CallbackQuery):
    """Заглушки для функций, которые пока не реализованы"""
    feature_names = {
        "user_management": "Управление пользователями",
        "account_management": "Управление счетами",
        "chat_management": "Управление чатом",
        "settings": "Настройки",
        "stats": "Статистика",
        "create_lottery": "Создание розыгрыша"
    }
    
    feature = feature_names.get(callback.data, "Функция")
    await callback.answer(f"🚧 {feature} в разработке", show_alert=True)


@router.callback_query(F.data == "start_registration")
async def registration_stub(callback: CallbackQuery):
    """Заглушка для регистрации"""
    await callback.answer("🚧 Регистрация в разработке", show_alert=True)


# === FALLBACK HANDLERS ===

@router.callback_query()
async def unknown_callback(callback: CallbackQuery):
    """Обработчик неизвестных callbacks"""
    logger.warning(f"Unknown callback data: {callback.data}")
    await callback.answer("❓ Неизвестная команда", show_alert=True)


@router.message()
async def unknown_message(message: Message):
    """Обработчик неизвестных сообщений"""
    await message.answer(
        "❓ Неизвестная команда. Используйте /start для начала работы."
    )


async def main():
    """Главная функция запуска бота"""
    logger.info("Запуск бота...")
    
    # Подключаем роутер
    dp.include_router(router)
    
    # Запускаем polling
    try:
        logger.info("Бот запущен")
        await dp.start_polling(bot)
    except Exception as e:
        logger.error(f"Ошибка при запуске бота: {e}")
    finally:
        await bot.session.close()


if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        logger.info("Бот остановлен пользователем")
    except Exception as e:
        logger.error(f"Критическая ошибка: {e}")