# telegram_bot.py - Telegram бот с кнопками

import os
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import Application, CommandHandler, CallbackQueryHandler, ContextTypes
from config import TELEGRAM_BOT_TOKEN, SUPER_ADMIN_ID, DATABASE_PATH, WINNERS_TXT_PATH, STREAM_STATS_TXT_PATH
from database import Database
from admin_manager import AdminManager


class TelegramBot:
    def __init__(self, database):
        self.db = database
        self.app = None
        self.admin_manager = AdminManager(SUPER_ADMIN_ID)
        self.chat_ids = set()  # Хранит ID чатов всех админов для рассылки

    # ========== КЛАВИАТУРЫ ==========

    def get_main_keyboard(self, is_super_admin=False):
        """Главное меню с кнопками"""
        keyboard = [
            [
                InlineKeyboardButton("🏆 Победители", callback_data="winners"),
                InlineKeyboardButton("📊 Статистика", callback_data="stats")
            ],
            [
                InlineKeyboardButton("📄 Файлы", callback_data="files"),
                InlineKeyboardButton("📈 Стримы", callback_data="streams")
            ]
        ]

        if is_super_admin:
            keyboard.append([
                InlineKeyboardButton("👥 Админы", callback_data="admins")
            ])

        keyboard.append([
            InlineKeyboardButton("ℹ️ Помощь", callback_data="help")
        ])

        return InlineKeyboardMarkup(keyboard)

    def get_files_keyboard(self):
        """Меню файлов"""
        keyboard = [
            [InlineKeyboardButton("💾 База данных", callback_data="file_database")],
            [InlineKeyboardButton("📄 winners.txt", callback_data="file_winners")],
            [InlineKeyboardButton("📄 stream_stats.txt", callback_data="file_stats")],
            [InlineKeyboardButton("◀️ Назад", callback_data="back_main")]
        ]
        return InlineKeyboardMarkup(keyboard)

    def get_admins_keyboard(self):
        """Меню управления админами"""
        keyboard = [
            [InlineKeyboardButton("👥 Список админов", callback_data="list_admins")],
            [InlineKeyboardButton("🆔 Мой ID", callback_data="my_id")],
            [InlineKeyboardButton("◀️ Назад", callback_data="back_main")]
        ]
        return InlineKeyboardMarkup(keyboard)

    def get_back_keyboard(self):
        """Кнопка назад"""
        keyboard = [[InlineKeyboardButton("◀️ Назад", callback_data="back_main")]]
        return InlineKeyboardMarkup(keyboard)

    # ========== КОМАНДЫ ==========

    async def start(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        """Команда /start"""
        user_id = update.effective_user.id

        # Сохраняем chat_id для рассылок
        if self.admin_manager.is_admin(user_id):
            self.chat_ids.add(update.effective_chat.id)

        if not self.admin_manager.is_admin(user_id):
            await update.message.reply_text("❌ У вас нет доступа!")
            return

        is_super = self.admin_manager.is_super_admin(user_id)

        welcome_text = "🤖 Добро пожаловать в панель управления!\n\n"
        if is_super:
            welcome_text += "👑 Вы главный администратор\n\n"
        else:
            welcome_text += "🛡️ Вы администратор\n\n"

        welcome_text += "Выберите действие:"

        await update.message.reply_text(
            welcome_text,
            reply_markup=self.get_main_keyboard(is_super)
        )

    # ========== ОБРАБОТКА КНОПОК ==========

    async def button_handler(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        """Обработка нажатий на кнопки"""
        query = update.callback_query
        await query.answer()

        user_id = query.from_user.id

        if not self.admin_manager.is_admin(user_id):
            await query.edit_message_text("❌ У вас нет доступа!")
            return

        is_super = self.admin_manager.is_super_admin(user_id)
        data = query.data

        # Главное меню
        if data == "back_main":
            await query.edit_message_text(
                "Выберите действие:",
                reply_markup=self.get_main_keyboard(is_super)
            )

        # Победители
        elif data == "winners":
            await self.show_all_winners(query)

        # Статистика
        elif data == "stats":
            await self.show_stats(query)

        # Стримы
        elif data == "streams":
            await self.show_stream_stats(query)

        # Файлы
        elif data == "files":
            await query.edit_message_text(
                "📄 Выберите файл для скачивания:",
                reply_markup=self.get_files_keyboard()
            )

        # Скачивание файлов
        elif data == "file_database":
            await self.send_database_file(query)
        elif data == "file_winners":
            await self.send_winners_file(query)
        elif data == "file_stats":
            await self.send_stats_file(query)

        # Админы (только для главного админа)
        elif data == "admins":
            if is_super:
                await query.edit_message_text(
                    "👥 Управление администраторами:",
                    reply_markup=self.get_admins_keyboard()
                )
            else:
                await query.edit_message_text("❌ Только для главного админа!")

        elif data == "list_admins":
            if is_super:
                await self.show_admins_list(query)

        elif data == "my_id":
            await self.show_my_id(query)

        # Помощь
        elif data == "help":
            await self.show_help(query)

    # ========== ФУНКЦИИ ОТОБРАЖЕНИЯ ==========

    async def show_all_winners(self, query):
        """Показать ВСЕХ победителей"""
        try:
            winners = self.db.get_all_winners()

            if not winners:
                await query.edit_message_text(
                    "📋 Победителей пока нет!",
                    reply_markup=self.get_back_keyboard()
                )
                return

            # Формируем текст со ВСЕМИ победителями
            text = f"🏆 Все победители (всего: {len(winners)}):\n\n"

            for winner in winners:
                id_num, date_time, username, trade_offer = winner
                text += f"#{id_num} | {date_time}\n"
                text += f"👤 {username}\n"
                text += f"🔗 {trade_offer}\n\n"

                # Telegram ограничивает 4096 символов
                if len(text) > 3800:
                    await query.message.reply_text(text)
                    text = "🏆 Продолжение:\n\n"

            if text != "🏆 Продолжение:\n\n":
                await query.edit_message_text(
                    text,
                    reply_markup=self.get_back_keyboard()
                )
        except Exception as e:
            await query.edit_message_text(
                f"❌ Ошибка: {e}",
                reply_markup=self.get_back_keyboard()
            )

    async def show_stats(self, query):
        """Показать общую статистику"""
        try:
            stats = self.db.get_total_stats()

            if not stats:
                await query.edit_message_text(
                    "❌ Ошибка получения статистики!",
                    reply_markup=self.get_back_keyboard()
                )
                return

            avg_winners = stats['winners_count'] / max(stats['streams_count'], 1)
            avg_messages = stats['total_messages'] / max(stats['streams_count'], 1)

            text = f"""📈 Общая статистика:

🏆 Победителей: {stats['winners_count']}
🎮 Стримов: {stats['streams_count']}
💬 Всего сообщений: {stats['total_messages']}

📊 В среднем:
• Победителей на стрим: {avg_winners:.1f}
• Сообщений на стрим: {avg_messages:.0f}
"""

            await query.edit_message_text(
                text,
                reply_markup=self.get_back_keyboard()
            )
        except Exception as e:
            await query.edit_message_text(
                f"❌ Ошибка: {e}",
                reply_markup=self.get_back_keyboard()
            )

    async def show_stream_stats(self, query):
        """Показать статистику стримов"""
        try:
            stats = self.db.get_all_stream_stats()

            if not stats:
                await query.edit_message_text(
                    "📊 Статистики стримов пока нет!",
                    reply_markup=self.get_back_keyboard()
                )
                return

            text = "📊 Статистика стримов:\n\n"
            for stat in stats[:10]:
                id_num, start, end, duration, messages, users = stat
                text += f"Стрим #{id_num}\n"
                text += f"🕐 {start}\n"
                text += f"⏱ {duration}\n"
                text += f"💬 Сообщений: {messages}\n"
                text += f"👥 Активных: {len(users.split(', '))}\n"
                text += f"━━━━━━━━━━\n\n"

            await query.edit_message_text(
                text,
                reply_markup=self.get_back_keyboard()
            )
        except Exception as e:
            await query.edit_message_text(
                f"❌ Ошибка: {e}",
                reply_markup=self.get_back_keyboard()
            )

    async def show_admins_list(self, query):
        """Показать список админов"""
        admins = self.admin_manager.get_admin_list()

        if not admins:
            await query.edit_message_text(
                "📋 Список админов пуст!",
                reply_markup=self.get_admins_keyboard()
            )
            return

        text = "👥 Список администраторов:\n\n"

        for user_id, info in admins.items():
            role_emoji = "👑" if user_id == SUPER_ADMIN_ID else "🛡️"
            role_text = "Главный админ" if user_id == SUPER_ADMIN_ID else "Админ"

            text += f"{role_emoji} {info['username']}\n"
            text += f"   ID: {user_id}\n"
            text += f"   Роль: {role_text}\n"
            if info.get('added_by'):
                text += f"   Добавил: {info['added_by']}\n"
            text += "\n"

        text += "\n💡 Для добавления/удаления используйте команды:\n"
        text += "/addadmin <ID>\n"
        text += "/removeadmin <ID>"

        await query.edit_message_text(
            text,
            reply_markup=self.get_admins_keyboard()
        )

    async def show_my_id(self, query):
        """Показать мой ID"""
        user_id = query.from_user.id
        username = query.from_user.username or "Нет username"
        first_name = query.from_user.first_name or "Нет имени"

        is_admin = self.admin_manager.is_admin(user_id)
        is_super = self.admin_manager.is_super_admin(user_id)

        text = f"""👤 Ваша информация:

🆔 ID: {user_id}
📝 Username: @{username}
👨‍💻 Имя: {first_name}
"""

        if is_super:
            text += "\n👑 Роль: Главный администратор"
        elif is_admin:
            text += "\n🛡️ Роль: Администратор"

        await query.edit_message_text(
            text,
            reply_markup=self.get_admins_keyboard()
        )

    async def show_help(self, query):
        """Показать помощь"""
        text = """📖 Справка:

🏆 Победители - список всех победителей
📊 Статистика - общая статистика
📄 Файлы - скачать базы данных
📈 Стримы - статистика стримов
👥 Админы - управление (только главный админ)

🤖 Автоматические функции:
• В конце стрима бот автоматически отправит список победителей
• Статистика стрима сохраняется автоматически

📝 Команды для управления админами:
/addadmin <ID> - добавить админа
/removeadmin <ID> - удалить админа
/myid - узнать свой ID
"""

        await query.edit_message_text(
            text,
            reply_markup=self.get_back_keyboard()
        )

    # ========== ОТПРАВКА ФАЙЛОВ ==========

    async def send_database_file(self, query):
        """Отправить файл БД"""
        try:
            if os.path.exists(DATABASE_PATH):
                await query.message.reply_document(
                    document=open(DATABASE_PATH, 'rb'),
                    filename="giveaway_winners.db",
                    caption="💾 База данных"
                )
                await query.answer("✅ Файл отправлен!")
            else:
                await query.answer("❌ Файл не найден!", show_alert=True)
        except Exception as e:
            await query.answer(f"❌ Ошибка: {e}", show_alert=True)

    async def send_winners_file(self, query):
        """Отправить winners.txt"""
        try:
            if os.path.exists(WINNERS_TXT_PATH):
                await query.message.reply_document(
                    document=open(WINNERS_TXT_PATH, 'rb'),
                    filename="winners.txt",
                    caption="📄 winners.txt"
                )
                await query.answer("✅ Файл отправлен!")
            else:
                await query.answer("❌ Файл не найден!", show_alert=True)
        except Exception as e:
            await query.answer(f"❌ Ошибка: {e}", show_alert=True)

    async def send_stats_file(self, query):
        """Отправить stream_stats.txt"""
        try:
            if os.path.exists(STREAM_STATS_TXT_PATH):
                await query.message.reply_document(
                    document=open(STREAM_STATS_TXT_PATH, 'rb'),
                    filename="stream_stats.txt",
                    caption="📄 stream_stats.txt"
                )
                await query.answer("✅ Файл отправлен!")
            else:
                await query.answer("❌ Файл не найден!", show_alert=True)
        except Exception as e:
            await query.answer(f"❌ Ошибка: {e}", show_alert=True)

    # ========== КОМАНДЫ УПРАВЛЕНИЯ АДМИНАМИ ==========

    async def add_admin_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        """Команда /addadmin"""
        if not self.admin_manager.is_super_admin(update.effective_user.id):
            await update.message.reply_text("❌ Только главный администратор может добавлять админов!")
            return

        if not context.args or not context.args[0].isdigit():
            await update.message.reply_text("""❌ Неверный формат!

Использование: /addadmin <ID>
Пример: /addadmin 123456789""")
            return

        new_admin_id = int(context.args[0])
        username = context.args[1] if len(context.args) > 1 else f"User_{new_admin_id}"

        success, message = self.admin_manager.add_admin(
            new_admin_id,
            username,
            update.effective_user.id
        )

        await update.message.reply_text(message)

    async def remove_admin_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        """Команда /removeadmin"""
        if not self.admin_manager.is_super_admin(update.effective_user.id):
            await update.message.reply_text("❌ Только главный администратор может удалять админов!")
            return

        if not context.args or not context.args[0].isdigit():
            await update.message.reply_text("""❌ Неверный формат!

Использование: /removeadmin <ID>
Пример: /removeadmin 123456789""")
            return

        remove_admin_id = int(context.args[0])

        success, message = self.admin_manager.remove_admin(
            remove_admin_id,
            update.effective_user.id
        )

        await update.message.reply_text(message)

    async def my_id_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        """Команда /myid"""
        user_id = update.effective_user.id
        username = update.effective_user.username or "Нет username"

        await update.message.reply_text(f"""👤 Ваша информация:

🆔 ID: {user_id}
📝 Username: @{username}

💡 Отправьте этот ID главному администратору для получения доступа""")

    # ========== РАССЫЛКА ==========

    async def broadcast_stream_end(self, winners_count, stream_duration, total_messages):
        """Рассылка о завершении стрима всем админам"""
        if not self.chat_ids:
            print("⚠️ [TELEGRAM] Нет активных чатов для рассылки")
            return

        # Получаем последних победителей этого стрима
        winners = self.db.get_last_winners(winners_count)

        text = f"""🎬 Стрим завершён!

⏱ Длительность: {stream_duration}
💬 Сообщений: {total_messages}
🏆 Победителей: {winners_count}

📋 Список победителей:
"""

        for winner in winners:
            id_num, date_time, username, trade_offer = winner
            text += f"\n👤 {username}\n🔗 {trade_offer}\n"

        # Отправляем всем админам
        for chat_id in list(self.chat_ids):
            try:
                await self.app.bot.send_message(
                    chat_id=chat_id,
                    text=text
                )
                print(f"✅ [TELEGRAM] Рассылка отправлена в чат {chat_id}")
            except Exception as e:
                print(f"❌ [TELEGRAM] Ошибка отправки в чат {chat_id}: {e}")
                self.chat_ids.discard(chat_id)

    # ========== ЗАПУСК ==========

    def run(self):
        """Запуск Telegram бота"""
        print("✅ [TELEGRAM] Бот запускается...")

        self.app = Application.builder().token(TELEGRAM_BOT_TOKEN).build()

        # Регистрируем обработчики
        self.app.add_handler(CommandHandler("start", self.start))
        self.app.add_handler(CommandHandler("addadmin", self.add_admin_command))
        self.app.add_handler(CommandHandler("removeadmin", self.remove_admin_command))
        self.app.add_handler(CommandHandler("myid", self.my_id_command))
        self.app.add_handler(CallbackQueryHandler(self.button_handler))

        print("✅ [TELEGRAM] Бот запущен с кнопками!")

        # Запускаем polling
        self.app.run_polling(allowed_updates=Update.ALL_TYPES)