import asyncio
import logging
from typing import Optional

from aiogram import Bot, Dispatcher
from aiogram.client.default import DefaultBotProperties
from aiogram.fsm.storage.memory import MemoryStorage
from aiogram.fsm.strategy import FSMStrategy
from helper_bot.handlers.admin import admin_router
from helper_bot.handlers.callback import callback_router
from helper_bot.handlers.group import group_router
from helper_bot.handlers.private import private_router
from helper_bot.handlers.voice import VoiceHandlers
from helper_bot.middlewares.blacklist_middleware import BlacklistMiddleware
from helper_bot.middlewares.dependencies_middleware import \
    DependenciesMiddleware
from helper_bot.middlewares.metrics_middleware import (ErrorMetricsMiddleware,
                                                       MetricsMiddleware)
from helper_bot.middlewares.rate_limit_middleware import RateLimitMiddleware
from helper_bot.server_prometheus import (start_metrics_server,
                                          stop_metrics_server)


async def start_bot_with_retry(bot: Bot, dp: Dispatcher, max_retries: int = 5, base_delay: float = 1.0):
    """Запуск бота с автоматическим перезапуском при сетевых ошибках"""
    for attempt in range(max_retries):
        try:
            logging.info(f"Запуск бота (попытка {attempt + 1}/{max_retries})")
            await dp.start_polling(bot, skip_updates=True)
            break
        except Exception as e:
            error_msg = str(e).lower()
            if any(keyword in error_msg for keyword in ['network', 'disconnected', 'timeout', 'connection']):
                if attempt < max_retries - 1:
                    delay = base_delay * (2 ** attempt)  # Exponential backoff
                    logging.warning(f"Сетевая ошибка при запуске бота: {e}. Повтор через {delay:.1f}с (попытка {attempt + 1}/{max_retries})")
                    await asyncio.sleep(delay)
                    continue
                else:
                    logging.error(f"Превышено максимальное количество попыток запуска бота: {e}")
                    raise
            else:
                logging.error(f"Критическая ошибка при запуске бота: {e}")
                raise


async def start_bot(bdf):
    token = bdf.settings['Telegram']['bot_token']
    bot = Bot(token=token, default=DefaultBotProperties(
        parse_mode='HTML',
        link_preview_is_disabled=bdf.settings['Telegram']['preview_link']
    ), timeout=60.0)  # Увеличиваем timeout для стабильности
    
    dp = Dispatcher(storage=MemoryStorage(), fsm_strategy=FSMStrategy.GLOBAL_USER)
    
    # ✅ Оптимизированная регистрация middleware
    dp.update.outer_middleware(DependenciesMiddleware())
    dp.update.outer_middleware(MetricsMiddleware())
    dp.update.outer_middleware(BlacklistMiddleware())
    dp.update.outer_middleware(RateLimitMiddleware())
    
    # Создаем экземпляр VoiceHandlers
    voice_handlers = VoiceHandlers(bdf, bdf.settings)
    voice_router = voice_handlers.router
    
    # Middleware уже добавлены на уровне dispatcher
    dp.include_routers(admin_router, private_router, callback_router, group_router, voice_router)
    
    # Добавляем обработчик завершения для корректного закрытия
    @dp.shutdown()
    async def on_shutdown():
        logging.info("Bot shutdown initiated, cleaning up resources...")
        try:
            await bot.session.close()
            logging.info("Bot session closed successfully")
        except Exception as e:
            logging.error(f"Error closing bot session during shutdown: {e}")
    
    await bot.delete_webhook(drop_pending_updates=True)
    
    # Запускаем HTTP сервер для метрик параллельно с ботом
    metrics_host = bdf.settings.get('Metrics', {}).get('host', '0.0.0.0')
    metrics_port = bdf.settings.get('Metrics', {}).get('port', 8080)
    
    try:
        # Запускаем метрики сервер
        await start_metrics_server(metrics_host, metrics_port)
        
        logging.info(f"✅ Метрики сервер запущен на {metrics_host}:{metrics_port}")
        logging.info("✅ Метрики будут обновляться в реальном времени через middleware")
        
        # Запускаем бота с retry логикой
        await start_bot_with_retry(bot, dp)

        logging.info("✅ Бот запущен")
    except Exception as e:
        logging.error(f"❌ Ошибка запуска бота: {e}")
        raise
    finally:
        # Останавливаем метрики сервер при завершении
        try:
            await stop_metrics_server()
        except Exception as e:
            logging.error(f"Error stopping metrics server: {e}")
        
        # Закрываем сессию бота
        try:
            await bot.session.close()
        except Exception as e:
            logging.error(f"Error closing bot session: {e}")

    return bot