import asyncio

from telegram.ext import Application

from src.config import settings
from src.telegram_topic.services.topic_handler import TopicCommandHandler
from src.telegram_topic.services.topic_manager import TelegramTopicManager


async def main():
    # Create application
    application = Application.builder().token(settings.telegram.TELEGRAM_TOKEN).build()
    bot = application.bot

    # Create topic manager
    topic_manager = TelegramTopicManager(bot)
    topic_handler = TopicCommandHandler(topic_manager)

    topic_handler.register_handlers(application)

    # Start the bot with correct parameters
    await application.initialize()

    await application.start()

    await application.updater.start_polling(
        poll_interval=2.0,
        timeout=30,
        drop_pending_updates=True,
        allowed_updates=["message", "edited_message", "callback_query"],
    )


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

from telegram import Update
from telegram.ext import ContextTypes
from abc import ABC, abstractmethod
from telegram.ext import CommandHandler

from src.telegram_topic.services.topic_manager import TopicManager


class CommandHandlerBase(ABC):
    """Base abstract class for command handlers"""

    @abstractmethod
    def register_handlers(self, application) -> None:
        """Register command handlers in the application"""
        pass


class TopicCommandHandler(CommandHandlerBase):
    """Command handler for topic management"""

    def __init__(self, topic_manager: TopicManager):
        self.topic_manager = topic_manager

    def register_handlers(self, application) -> None:
        application.add_handler(CommandHandler("create_topic", self.create_topic_command))
        application.add_handler(CommandHandler("edit_topic", self.edit_topic_command))

    async def create_topic_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
        """Handler for the create topic command"""
        if not context.args or len(context.args) < 1:
            await update.message.reply_text("Usage: /create_topic <topic_name> [icon_color (0-7)]")
            return

        name = context.args[0]
        icon_color = int(context.args[1]) if len(context.args) > 1 else None

        try:
            chat_id = update.effective_chat.id
            forum_topic = await self.topic_manager.create_topic(chat_id, name, icon_color)
            await update.message.reply_text(f"Topic '{name}' created successfully! Topic ID: {forum_topic.message_thread_id}")
        except Exception as e:
            await update.message.reply_text(f"Error creating topic: {e}")

    async def edit_topic_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
        """Handler for the edit topic command"""
        if not context.args or len(context.args) < 2:
            await update.message.reply_text("Usage: /edit_topic <topic_id> <new_name>")
            return

        try:
            message_thread_id = int(context.args[0])
            name = context.args[1]

            chat_id = update.effective_chat.id
            result = await self.topic_manager.edit_topic(chat_id, message_thread_id, name)

            if result:
                await update.message.reply_text("Topic edited successfully!")
            else:
                await update.message.reply_text("Failed to edit topic")
        except Exception as e:
            await update.message.reply_text(f"Error editing topic: {e}")

from telegram import ForumTopic, Bot
from telegram.constants import ChatType
from src.config import log
from abc import ABC, abstractmethod


class TopicManager(ABC):
    """Abstract class for topic management"""

    @abstractmethod
    async def create_topic(self, chat_id: int, name: str, icon_color: int = None) -> ForumTopic:
        """Create a new topic"""
        pass

    @abstractmethod
    async def edit_topic(
        self,
        chat_id: int,
        message_thread_id: int,
        name: str = None,
        icon_custom_emoji_id: str = None,
    ) -> bool:
        """Edit an existing topic"""
        pass


class TelegramTopicManager(TopicManager):
    """Implementation of the Topic Manager for Telegram"""

    def __init__(self, bot: Bot):
        """
        Initialize the topic manager

        Args:
            bot (Bot): Telegram bot instance
        """
        self.bot = bot

    async def create_topic(self, chat_id: int, name: str, icon_color: int = None) -> ForumTopic:
        """
        Create a new topic in a group

        Args:
            chat_id (int): Group ID
            name (str): Topic name
            icon_color (int, optional): Topic icon color (0-7)

        Returns:
            ForumTopic: Information about the created topic

        Raises:
            ValueError: If the group is not a supergroup
            Exception: If topic creation fails
        """
        log.debug(f"{chat_id=}")
        try:
            # Check that this is a supergroup (topics only work in supergroups)
            chat = await self.bot.get_chat(chat_id)

            if chat.type != ChatType.SUPERGROUP:
                raise ValueError("Topics are only available in supergroups")

            # Create the topic
            params = {"chat_id": chat_id, "name": name}

            if icon_color is not None:
                params["icon_color"] = icon_color

            forum_topic = await self.bot.create_forum_topic(**params)

            return forum_topic

        except Exception as e:
            log.error(f"Error creating topic: {e}")
            raise

    async def edit_topic(
        self,
        chat_id: int,
        message_thread_id: int,
        name: str = None,
        icon_custom_emoji_id: str = None,
    ) -> bool:
        """
        Edit an existing topic

        Args:
            chat_id (int): Group ID
            message_thread_id (int): Topic ID
            name (str, optional): New topic name
            icon_custom_emoji_id (str, optional): Emoji ID for topic icon

        Returns:
            bool: True if editing was successful

        Raises:
            Exception: If topic editing fails
        """
        try:
            params = {"chat_id": chat_id, "message_thread_id": message_thread_id}

            if name is not None:
                params["name"] = name

            if icon_custom_emoji_id is not None:
                params["icon_custom_emoji_id"] = icon_custom_emoji_id

            result = await self.bot.edit_forum_topic(**params)
            return result
        except Exception as e:
            log.error(f"Error editing topic: {e}")
            raise