"""
Главный файл бота с сохранением задач.
"""

import asyncio
import logging
from aiogram import Bot, Dispatcher
from aiogram.types import BotCommand
from aiogram.client.session.aiohttp import AiohttpSession
from config.settings import settings
from core.logger import setup_logger
from managers.proxy_manager import ProxyManager
from managers.background_tasks import BackgroundTaskManager
from services.browser_service import BrowserService
from handlers.commands import BotInterface
from managers.storage import TaskStorage, ChatStorage

logger = setup_logger(__name__)


async def set_bot_commands(bot: Bot):
    """Устанавливает команды бота в меню."""
    commands = [
        BotCommand(command="start", description="🏠 Главное меню"),
        BotCommand(command="register", description="🔐 Зарегистрироваться"),
        BotCommand(command="login", description="🔑 Войти"),
        BotCommand(command="logout", description="🔒 Выйти"),
        BotCommand(command="streamers", description="📺 Стримеры"),
        BotCommand(command="tasks", description="📊 Задачи"),
        BotCommand(command="status", description="📈 Статус"),
    ]
    await bot.set_my_commands(commands)


class BotApplication:
    
    def __init__(self):
        self.bot: Bot = None
        self.dispatcher: Dispatcher = None
        
        self.proxy_manager = ProxyManager()
        self.background_tasks = BackgroundTaskManager()
        self.browser_service = BrowserService(self.proxy_manager)
        self.storage = TaskStorage()
        self.chat_storage = ChatStorage()
        
        self.interface = BotInterface(
            background_tasks=self.background_tasks,
            proxy_manager=self.proxy_manager,
            browser_service=self.browser_service,
            storage=self.storage,
            chat_storage=self.chat_storage,
        )
    
    async def initialize(self):
        """Инициализация бота."""
        logger.info("Initializing bot...")
        
        if not settings.BOT_TOKEN:
            raise ValueError("BOT_TOKEN not set!")
         

        self.bot = Bot(token=settings.BOT_TOKEN)
        self.dispatcher = Dispatcher()
        
        self.interface.register(self.dispatcher)
        await set_bot_commands(self.bot)
        
        # Восстанавливаем задачи
        await self._restore_tasks()
        
        logger.info(f"Proxies: {self.proxy_manager.count}")
        logger.info("Bot initialized!")
    
    async def _restore_tasks(self):
        """Восстанавливает задачи после перезапуска."""
        saved_tasks = await self.storage.load_tasks()
        
        if not saved_tasks:
            logger.info("No tasks to restore")
            return
        
        restored = 0
        for task_id, params in saved_tasks.items():
            if params.completed or params.stopped:
                continue
            
            await self.interface.task_manager.add_task(task_id, params)
            
            if params.task_type == "twitch_irc" and params.chat_id:
                class FakeMsg:
                    chat = type('obj', (object,), {'id': params.chat_id})
                    bot = self.bot
                
                await self.background_tasks.start_task(
                    task_id=task_id,
                    coro=self.interface._run_twitch(task_id, params, FakeMsg()),
                    task_type="twitch_irc",
                    metadata={'type': 'twitch_irc', 'channel': params.channel, 'chat_id': params.chat_id}
                )
                restored += 1
        
        logger.info(f"🔄 Restored {restored} tasks")
    
    async def start(self):
        """Запуск бота."""
        await self.initialize()  # ← ВОТ ЭТО БЫЛО ПРОПУЩЕНО
        logger.info("Starting polling...")
        await self.dispatcher.start_polling(self.bot)
    
    async def stop(self):
        """Остановка с сохранением."""
        logger.info("Shutting down...")
        
        # Сохраняем задачи
        tasks = self.interface.task_manager._tasks
        await self.storage.save_tasks(tasks)
        
        await self.background_tasks.cancel_all()
        await self.browser_service.cleanup()
        if self.bot:
            await self.bot.session.close()
        logger.info("Bot stopped")


async def main():
    app = BotApplication()
    try:
        await app.start()
    except KeyboardInterrupt:
        logger.info("Interrupted")
    finally:
        await app.stop()


if __name__ == "__main__":
    asyncio.run(main())