"""
Новая модульная версия 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, SimpleEventIsolation
from aiogram.fsm.storage.redis import RedisStorage, DefaultKeyBuilder
from aiogram.client.session.aiohttp import AiohttpSession
from aiogram.fsm.context import FSMContext

from src.filters.case_insensitive import CaseInsensitiveCommand

from src.core.config import BOT_TOKEN, REDIS_URL, FSM_TTL_SECONDS, LOG_LEVEL
from src.core.access import is_admin, is_staff
from src.middlewares.access import AccessMiddleware
from src.core.database import async_session_maker
from src.core.scheduler import bot_scheduler
from src.container import container
from src.interfaces.base import IBotController
from src.middlewares.activity import ActivityMiddleware
from src.handlers.admin_panel import admin_router
from src.handlers.registration_handlers import router as registration_router
from src.handlers.admin_account_handlers import router as admin_account_router
from src.handlers.redraw_handlers import router as redraw_router
from src.handlers.chat_handlers import router as chat_router
from src.handlers.admin_chat_handlers import router as admin_chat_router
from src.handlers.account_handlers import account_router
from src.handlers.message_management import message_admin_router
from src.handlers.p2p_chat import router as p2p_chat_router
from src.handlers.help_handlers import router as help_router
from src.handlers.admin_emoji_handlers import router as admin_emoji_router

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

# Создание бота и диспетчера
bot = Bot(token=BOT_TOKEN, session=AiohttpSession(timeout=30, limit=100))
if REDIS_URL:
    storage = RedisStorage.from_url(
        REDIS_URL, key_builder=DefaultKeyBuilder(with_bot_id=True),
        state_ttl=FSM_TTL_SECONDS, data_ttl=FSM_TTL_SECONDS,
    )
    isolation = storage.create_isolation(lock_kwargs={"timeout": 3600})
else:
    storage = MemoryStorage()
    isolation = SimpleEventIsolation()
dp = Dispatcher(storage=storage, events_isolation=isolation)
router = Router()


@router.message(CaseInsensitiveCommand("cancel"))
async def cancel_dialog(message: Message, state: FSMContext):
    await state.clear()
    await message.answer("Операция отменена. /start — главное меню, /cashier — касса.")


# Middleware для логирования всех callback'ов
@dp.callback_query.middleware()
async def log_callback_middleware(handler, event, data):
    """Middleware для логирования всех callback запросов"""
    logger.warning(f"🔔 MIDDLEWARE CALLBACK: data='{event.data}', user_id={event.from_user.id}")
    result = await handler(event, data)
    logger.warning(f"🔔 MIDDLEWARE CALLBACK HANDLED: data='{event.data}', result={result}")
    return result


@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(CaseInsensitiveCommand("start"))
async def cmd_start(message: Message, state: FSMContext):
    """Обработчик команды /start (регистронезависимо)"""
    await state.clear()
    async with get_controller() as controller:
        await controller.handle_start(message)


# === TEXT BUTTON HANDLERS ===

@router.message(F.text == "🎰 Розыгрыши")
async def btn_lotteries(message: Message):
    """Обработчик кнопки 'Розыгрыши'"""
    from src.core.database import async_session_maker
    from src.repositories.implementations import LotteryRepository, ParticipationRepository
    from src.components.ui import MessageFormatterImpl
    from src.components.ui import KeyboardBuilderImpl
    from src.core.services import UserService
    from src.core.config import ADMIN_IDS
    
    async with async_session_maker() as session:
        lottery_repo = LotteryRepository(session)
        participation_repo = ParticipationRepository(session)
        lotteries = await lottery_repo.get_active()
        
        if not lotteries:
            await message.answer("❌ Нет активных розыгрышей")
            return
        
        text = "🎲 **Активные розыгрыши:**\n\n"
        formatter = MessageFormatterImpl()
        
        for lottery in lotteries:
            participants_count = await participation_repo.get_count_by_lottery(lottery.id)
            lottery_info = formatter.format_lottery_info(lottery, participants_count)
            await message.answer(lottery_info, parse_mode="HTML")
        
        # Получаем информацию о регистрации пользователя
        user = await UserService.get_or_create_user(
            session,
            telegram_id=message.from_user.id,
            username=message.from_user.username,
            first_name=message.from_user.first_name,
            last_name=message.from_user.last_name
        )
        
        keyboard_builder = KeyboardBuilderImpl()
        keyboard = keyboard_builder.get_main_keyboard(
            is_admin=await is_admin(message.from_user.id),
            is_registered=user.is_registered
        )
        
        await message.answer(
            text,
            reply_markup=keyboard,
            parse_mode="Markdown"
        )


@router.message(F.text == "💬 Чат")
async def btn_chat(message: Message, state: FSMContext):
    """Обработчик кнопки 'Чат'"""
    from src.handlers.chat_handlers import enter_chat
    await enter_chat(message, state)


@router.message(F.text == "📝 Регистрация")
async def btn_registration(message: Message, state: FSMContext):
    from src.handlers.registration_handlers import begin_registration
    await begin_registration(message, state)
    


@router.message(CaseInsensitiveCommand("register"))
async def cmd_register(message: Message, state: FSMContext):
    """Обработчик команды /register (регистронезависимо)"""
    await btn_registration(message, state)


@router.message(F.text.lower().in_(["регистрация", "регистр", "register"]))
async def text_registration(message: Message, state: FSMContext):
    """Обработчик текста для регистрации"""
    await btn_registration(message, state)


@router.message(F.text == "🔑 Мой код")
async def btn_my_code(message: Message):
    """Обработчик кнопки 'Мой код'"""
    from src.handlers.registration_handlers import show_verification_code
    await show_verification_code(message)


@router.message(F.text.in_({"📱 Мои логины", "💳 Мои логины", "� Мои логины"}))
async def btn_my_accounts(message: Message):
    """Обработчик кнопки 'Мои логины'"""
    from src.handlers.registration_handlers import show_user_accounts
    await show_user_accounts(message)


@router.message(F.text == "❓ Справка")
async def btn_help(message: Message):
    """Обработчик кнопки 'Справка'"""
    from src.handlers.help_handlers import show_help_main
    await show_help_main(message)


@router.message(F.text == "⚙️ Админ панель")
async def btn_admin(message: Message):
    """Обработчик кнопки 'Админ панель'"""
    await cmd_admin(message)


@router.message(F.text == "🚪 Выйти из чата")
async def btn_exit_chat(message: Message, state: FSMContext):
    """Обработчик кнопки 'Выйти из чата'"""
    from src.handlers.chat_handlers import exit_chat
    await exit_chat(message, state)


@router.message(F.text == "🏠 Главная")
async def btn_main_menu(message: Message, state: FSMContext):
    """Обработчик кнопки 'Главная'"""
    await cmd_start(message, state)


@router.message(CaseInsensitiveCommand("admin"))
async def cmd_admin(message: Message):
    """Обработчик команды /admin (регистронезависимо) - перенаправляет в admin_panel"""
    from src.core.config import ADMIN_IDS
    from src.core.database import async_session_maker
    from src.core.models import User
    from sqlalchemy import select
    
    # Проверяем, является ли пользователь главным администратором из .env
    user_id = message.from_user.id
    is_super_admin = user_id in ADMIN_IDS
    
    # Проверяем, является ли пользователь назначенным администратором
    is_assigned_admin = False
    if not is_super_admin:
        async with async_session_maker() as session:
            user = await session.execute(
                select(User).where(User.telegram_id == user_id)
            )
            user = user.scalar_one_or_none()
            is_assigned_admin = user and user.is_admin
    
    # Если не администратор ни того, ни другого типа
    if not (is_super_admin or is_assigned_admin):
        await message.answer("❌ Недостаточно прав для доступа к админ панели")
        return
    
    # Отправляем сообщение с кнопкой админ панели
    from src.components.ui import KeyboardBuilderImpl
    kb = KeyboardBuilderImpl()
    keyboard = kb.get_admin_keyboard()
    
    text = "⚙️ **Панель администратора**\n\n"
    text += "Выберите раздел для управления:"
    
    await message.answer(text, reply_markup=keyboard, parse_mode="Markdown")


# === CALLBACK HANDLERS ===

@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 == "back_to_main")
async def back_to_main_handler(callback: CallbackQuery, state: FSMContext):
    """Обработчик возврата в главное меню"""
    await state.clear()
    await callback.answer()
    async with get_controller() as controller:
        await controller.handle_start(callback.message, actor=callback.from_user)
# Функции обрабатываются в:
# - admin_panel.py: создание розыгрышей, управление пользователями, счетами, чатом, статистика
# - registration_handlers.py: регистрация пользователей
# - admin_account_handlers.py: управление счетами
# - admin_chat_handlers.py: управление чатом
# - chat_handlers.py: пользовательский чат


# === FALLBACK HANDLERS ===
# Обработка неизвестных callback и сообщений происходит в соответствующих роутерах


def configure_dispatcher():
    """Главная функция запуска бота"""
    logger.info("Запуск бота...")
    from src.middlewares.runtime import PrivateDialogMiddleware, ErrorMiddleware
    for observer in (dp.message, dp.callback_query):
        observer.outer_middleware(PrivateDialogMiddleware())
        observer.outer_middleware(ErrorMiddleware())
    
    # Подключаем middleware для отслеживания активности
    dp.message.middleware(ActivityMiddleware())
    dp.callback_query.middleware(ActivityMiddleware())
    
    # Enforce access on every selected handler, including stale FSM callbacks.
    from src.middlewares.access import ChatAccessMiddleware
    p2p_chat_router.message.middleware(ChatAccessMiddleware())
    p2p_chat_router.callback_query.middleware(ChatAccessMiddleware())
    for protected in (admin_router, admin_chat_router, redraw_router, message_admin_router, admin_emoji_router):
        protected.message.middleware(AccessMiddleware())
        protected.callback_query.middleware(AccessMiddleware(
            public_handlers={"confirm_winner_callback"} if protected is redraw_router else (),
        ))
    for protected in (admin_account_router,):
        protected.message.middleware(AccessMiddleware(allow_cashier=True))
        protected.callback_query.middleware(AccessMiddleware(
            allow_cashier=True, public_handlers={"view_my_accounts_callback"},
        ))

    # Подключаем роутеры в правильном порядке
    # 1. Основной роутер main.py с базовыми командами (/start, /help, /admin)
    dp.include_router(router)
    from src.handlers.cashier_handlers import cashier_router
    dp.include_router(cashier_router)
    
    # 2. Специфичные роутеры
    dp.include_router(message_admin_router)  # Управление сообщениями администратором
    dp.include_router(admin_emoji_router)  # Управление кастомными эмодзи
    dp.include_router(admin_router)  # Админ панель - самая высокая специфичность
    dp.include_router(registration_router)  # Регистрация
    dp.include_router(admin_account_router)  # Админские команды счетов
    dp.include_router(admin_chat_router)  # Админские команды чата
    dp.include_router(redraw_router)  # Повторные розыгрыши
    dp.include_router(p2p_chat_router)  # P2P чат между пользователями
    dp.include_router(help_router)  # Справка и помощь
    
    # 3. Chat router для broadcast (обрабатывает обычные сообщения)
    dp.include_router(chat_router)  # Пользовательский чат (broadcast всем) - РАНЬШЕ account_router
    
    # 4. Account router для обнаружения счетов (обрабатывает сообщения со счетами от админов)
    dp.include_router(account_router)  # Обнаружение счетов для админов - ПОСЛЕ chat_router
    


async def main():
    configure_dispatcher()
    # Запускаем планировщик задач
    bot_scheduler.start()
    logger.info("Планировщик задач запущен")
    
    # Запускаем polling
    try:
        from src.core.health import HEARTBEAT, heartbeat, start_watchdog
        HEARTBEAT.unlink(missing_ok=True)
        watchdog = start_watchdog()
        if REDIS_URL:
            await storage.redis.ping()
        from sqlalchemy import select
        from src.core.models import User
        async with async_session_maker() as session:
            await session.execute(select(User).limit(0))
        await bot.get_me()
        health_task = asyncio.create_task(heartbeat(), name="database-heartbeat")
        logger.info("Бот запущен")
        polling_task = asyncio.create_task(dp.start_polling(bot))
        completed, _ = await asyncio.wait({health_task, polling_task}, return_when=asyncio.FIRST_COMPLETED)
        for task in completed:
            await task
    except Exception:
        logger.exception("Runtime supervision failed; stopping the application")
        raise
    finally:
        from src.core.database import close_db
        from contextlib import suppress
        for task_name in ("polling_task", "health_task"):
            task = locals().get(task_name)
            if task is not None:
                task.cancel()
                with suppress(asyncio.CancelledError, Exception):
                    await task
        HEARTBEAT.unlink(missing_ok=True)
        # Останавливаем планировщик
        bot_scheduler.shutdown()
        await bot.session.close()
        await storage.close()
        await close_db()
        if "watchdog" in locals():
            watchdog.set()


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