# Основные типы медиа в Telegram
MEDIA_TYPES = {
    'photo': {
        'extensions': ['.jpg', '.jpeg', '.png', '.webp'],
        'max_size': '10MB',
        'description': 'Изображения'
    },
    'document': {
        'extensions': ['.pdf', '.doc', '.docx', '.txt', '.zip', '.rar'],
        'max_size': '2GB',
        'description': 'Документы'
    },
    'video': {
        'extensions': ['.mp4', '.avi', '.mov', '.mkv'],
        'max_size': '2GB',
        'description': 'Видео файлы'
    },
    'audio': {
        'extensions': ['.mp3', '.wav', '.ogg', '.m4a'],
        'max_size': '50MB',
        'description': 'Аудио файлы'
    },
    'voice': {
        'extensions': ['.ogg'],
        'max_size': '20MB',
        'description': 'Голосовые сообщения'
    },
    'video_note': {
        'extensions': ['.mp4'],
        'max_size': '1MB',
        'description': 'Видеосообщения'
    },
    'sticker': {
        'extensions': ['.webp', '.tgs'],
        'max_size': '512KB',
        'description': 'Стикеры'
    },
    'animation': {
        'extensions': ['.gif', '.mp4'],
        'max_size': '50MB',
        'description': 'GIF анимации'
    }
}

# handlers/media_handlers.py
import os
import requests
from PIL import Image
from telegram import Update
from telegram.ext import ContextTypes
import logging

logger = logging.getLogger(__name__)

async def handle_photo(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обработка фотографий"""
    photo = update.message.photo[-1]  # Берем фото наивысшего качества
    user = update.effective_user
    
    try:
        # Получение информации о файле
        file_info = await context.bot.get_file(photo.file_id)
        
        # Создание директории для сохранения
        os.makedirs('downloads/photos', exist_ok=True)
        
        # Путь для сохранения
        file_path = f"downloads/photos/{photo.file_id}.jpg"
        
        # Скачивание файла
        await file_info.download_to_drive(file_path)
        
        # Получение метаданных изображения
        with Image.open(file_path) as img:
            width, height = img.size
            format_type = img.format
            mode = img.mode
        
        # Отправка информации о фото
        info_text = f"""
📸 Фото получено!

📏 Размер: {width}x{height} пикселей
📁 Формат: {format_type}
🎨 Режим: {mode}
💾 Размер файла: {os.path.getsize(file_path)} байт
🆔 File ID: {photo.file_id}
        """
        
        await update.message.reply_text(info_text, parse_mode='Markdown')
        
        # Отправка обработанного изображения
        await send_processed_image(update, context, file_path)
        
    except Exception as e:
        logger.error(f"Ошибка при обработке фото: {e}")
        await update.message.reply_text("❌ Произошла ошибка при обработке фото.")

async def send_processed_image(update: Update, context: ContextTypes.DEFAULT_TYPE, image_path: str):
    """Отправка обработанного изображения"""
    try:
        # Создание миниатюры
        thumbnail_path = create_thumbnail(image_path)
        
        # Отправка оригинального изображения с подписью
        with open(image_path, 'rb') as photo_file:
            await context.bot.send_photo(
                chat_id=update.effective_chat.id,
                photo=photo_file,
                caption="🖼️ Обработанное изображение"
            )
        
        # Отправка миниатюры
        with open(thumbnail_path, 'rb') as thumb_file:
            await context.bot.send_photo(
                chat_id=update.effective_chat.id,
                photo=thumb_file,
                caption="🔍 Миниатюра"
            )
        
        # Удаление временных файлов
        os.remove(thumbnail_path)
        
    except Exception as e:
        logger.error(f"Ошибка при отправке обработанного изображения: {e}")

def create_thumbnail(image_path: str, size: tuple = (200, 200)) -> str:
    """Создание миниатюры изображения"""
    thumbnail_path = image_path.replace('.jpg', '_thumb.jpg')
    
    with Image.open(image_path) as img:
        img.thumbnail(size, Image.Resampling.LANCZOS)
        img.save(thumbnail_path, 'JPEG', quality=85)
    
    return thumbnail_path

async def handle_photo_album(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обработка альбома фотографий"""
    if update.message.media_group_id:
        # Это часть медиа-группы (альбом)
        media_group_id = update.message.media_group_id
        
        # Проверяем, обрабатывали ли мы уже этот альбом
        if hasattr(context, 'processed_albums'):
            if media_group_id in context.processed_albums:
                return
        else:
            context.processed_albums = set()
        
        context.processed_albums.add(media_group_id)
        
        # Обрабатываем только первое фото из альбома
        photo = update.message.photo[-1]
        
        try:
            file_info = await context.bot.get_file(photo.file_id)
            file_path = f"downloads/albums/{media_group_id}_{photo.file_id}.jpg"
            
            os.makedirs('downloads/albums', exist_ok=True)
            await file_info.download_to_drive(file_path)
            
            await update.message.reply_text(
                f"📸 Альбом получен!\n"
                f"🆔 Media Group ID: {media_group_id}\n"
                f"📁 Файл сохранен: {file_path}",
                parse_mode='Markdown'
            )
            
        except Exception as e:
            logger.error(f"Ошибка при обработке альбома: {e}")

async def handle_video_note(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обработка видеосообщений"""
    video_note = update.message.video_note
    
    try:
        file_info = await context.bot.get_file(video_note.file_id)
        
        # Создание директории для видеосообщений
        os.makedirs('downloads/video_notes', exist_ok=True)
        
        file_path = f"downloads/video_notes/{video_note.file_id}.mp4"
        await file_info.download_to_drive(file_path)
        
        # Информация о видеосообщении
        duration_minutes = video_note.duration // 60
        duration_seconds = video_note.duration % 60
        
        info_text = f"""
📹 Видеосообщение получено!

📏 Размер: {video_note.length}x{video_note.length} (квадратное)
⏱️ Длительность: {duration_minutes}:{duration_seconds:02d}
📏 Размер файла: {video_note.file_size / (1024 * 1024):.2f} MB
🆔 File ID: {video_note.file_id}`
        """
        
        await update.message.reply_text(info_text, parse_mode='Markdown')
        
    except Exception as e:
        logger.error(f"Ошибка при обработке видеосообщения: {e}")

# utils/error_handler.py
import logging
from telegram import Update
from telegram.ext import ContextTypes

logger = logging.getLogger(__name__)

async def handle_media_error(update: Update, context: ContextTypes.DEFAULT_TYPE, error: Exception):
    """Универсальный обработчик ошибок медиа"""
    error_messages = {
        'FileNotFoundError': '❌ Файл не найден. Возможно, он был удален.',
        'PermissionError': '❌ Нет прав доступа к файлу.',
        'OSError': '❌ Ошибка операционной системы при работе с файлом.',
        'ValueError': '❌ Некорректные данные файла.',
        'MemoryError': '❌ Недостаточно памяти для обработки файла.',
        'TimeoutError': '❌ Превышено время ожидания при загрузке файла.'
    }
    
    error_type = type(error).__name__
    user_message = error_messages.get(error_type, f'❌ Произошла ошибка: {error_type}')
    
    await update.message.reply_text(user_message)
    logger.error(f"Ошибка при обработке медиа: {error}", exc_info=True)

# Декоратор для обработки ошибок
def media_error_handler(func):
    """Декоратор для обработки ошибок в медиа-функциях"""
    async def wrapper(update: Update, context: ContextTypes.DEFAULT_TYPE):
        try:
            await func(update, context)
        except Exception as e:
            await handle_media_error(update, context, e)
    return wrapper

# bot_with_media.py
import logging
from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
from handlers.media_handlers import *
from utils.error_handler import media_error_handler
import os
from dotenv import load_dotenv

load_dotenv()

logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO
)
logger = logging.getLogger(__name__)

BOT_TOKEN = os.getenv('BOT_TOKEN')

@media_error_handler
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Команда /start"""
    await update.message.reply_text(
        "🤖 Добро пожаловать в бот для обработки медиа!\n\n"
        "Отправьте мне:\n"
        "📸 Фото\n"
        "📄 Документ\n"
        "🎵 Аудио\n"
        "🎬 Видео\n"
        "🎤 Голосовое сообщение\n"
        "📹 Видеосообщение\n"
        "😀 Стикер\n"
        "🎭 GIF анимацию"
    )

def main():
    """Основная функция запуска бота"""
    if not BOT_TOKEN:
        logger.error("BOT_TOKEN не найден!")
        return
    
    # Создание приложения
    application = Application.builder().token(BOT_TOKEN).build()
    
    # Добавление обработчиков команд
    application.add_handler(CommandHandler("start", start))
    
    # Добавление обработчиков медиа
    application.add_handler(MessageHandler(filters.PHOTO, handle_photo))
    application.add_handler(MessageHandler(filters.Document.ALL, handle_document))
    application.add_handler(MessageHandler(filters.AUDIO, handle_audio))
    application.add_handler(MessageHandler(filters.VIDEO, handle_video))
    application.add_handler(MessageHandler(filters.VOICE, handle_voice))
    application.add_handler(MessageHandler(filters.VIDEO_NOTE, handle_video_note))
    application.add_handler(MessageHandler(filters.STICKER, handle_sticker))
    application.add_handler(MessageHandler(filters.ANIMATION, handle_animation))
    
    # Запуск бота
    logger.info("Бот для обработки медиа запущен!")
    application.run_polling()

if __name__ == '__main__':
    main()