youtube_video_handler.py

import asyncio
import shutil
import httpx
import os # Adicionar import os
import re # Importar re para expressões regulares
import logging # Importar logging

from telegram import Update
from telegram.ext import ContextTypes

from services.youtube_video import download_youtube_video
from utils.ansi_stripper import strip_ansi_codes
from handlers.commands import DOWNLOAD_COUNT # Importar DOWNLOAD_COUNT

logger = logging.getLogger(__name__) # Obter o logger

async def process_youtube_video(update: Update, context: ContextTypes.DEFAULT_TYPE,
                                url: str = None, progress_message=None):

    url = url or update.message.text
    if progress_message is None:
        progress_message = await update.message.reply_text("🎬 Baixando vídeo...")

    loop = asyncio.get_running_loop()
    last_time = 0

    async def update_progress(raw_progress_line):
        nonlocal last_time
        current_time = loop.time()
        if current_time - last_time > 2: # Atualiza a cada 2 segundos para evitar flood
            last_time = current_time
            
            logger.debug(f"Raw progress line: {raw_progress_line}")

            # Regex mais simples para extrair porcentagem e ETA
            # Ex: "[download]  57.6% of    1.20GiB at  4.20MiB/s ETA 00:04"
            match = re.search(r"\[download\]\s+(?P<percent>\d+\.\d+)%.*ETA\s+(?P<eta>\d{2}:\d{2})", raw_progress_line)
            
            progress_text = "Progresso: N/A"
            eta_text = "Tempo estimado: N/A"

            if match:
                percent = match.group("percent")
                eta = match.group("eta")
                progress_text = f"Progresso: {percent}%"
                eta_text = f"Tempo estimado: {eta}"
                logger.debug(f"Parsed progress: Percent={percent}, ETA={eta}")
            else:
                # Se não encontrar o padrão principal, tenta pegar outras informações úteis
                if "download" in raw_progress_line.lower():
                    progress_text = f"Progresso: {raw_progress_line}"
                logger.debug(f"No simple match, using raw line: {progress_text}")

            message_to_send = (
                "🎬 Baixando vídeo...\n"
                f"{progress_text}\n"
                f"{eta_text}"
            )
            logger.debug(f"Message to send: {message_to_send}")

            try:
                await progress_message.edit_text(message_to_send)
            except Exception as e:
                logger.error(f"Erro ao editar mensagem de progresso: {e}")
                pass # Ignora erros de edição de mensagem (ex: mensagem inalterada)

    try:
        file_path, title, temp_dir = await download_youtube_video(url, update_progress)

        await progress_message.edit_text("📤 Enviando arquivo...")

        # Decide se envia como video ou documento
        size_mb = (await asyncio.to_thread(os.path.getsize, file_path) / 1024 / 1024)

        if size_mb <= 50:
            await context.bot.send_video(
                chat_id=update.effective_chat.id,
                video=await asyncio.to_thread(open, file_path, 'rb'), # Envia o conteúdo como bytes
                caption=f"🎥 {title}",
            )
        else:
            await context.bot.send_document(
                chat_id=update.effective_chat.id,
                document=await asyncio.to_thread(open, file_path, 'rb'), # Envia o conteúdo como bytes
                filename=f"{title}.mp4",
                caption=f"📁 Arquivo grande enviado como documento ({int(size_mb)}MB).",
            )

        await progress_message.delete()
        global DOWNLOAD_COUNT
        DOWNLOAD_COUNT += 1 # Incrementa o contador de downloads


    except httpx.ReadError:
        await progress_message.edit_text(
            "❌ Erro: O arquivo de vídeo pode ser muito grande para ser enviado ao Telegram. "
            "O limite para bots é de 50MB. Tente um vídeo mais curto."
        )
    except Exception as e: # Captura Exception genérica para erros do subprocesso
        error_message = str(e)
        if "Erro ao baixar do YouTube:" in error_message:
            await progress_message.edit_text(f"❌ {error_message}")
        elif "A operação de download do YouTube excedeu o tempo limite" in error_message:
            await progress_message.edit_text(f"❌ {error_message}")
        else:
            await progress_message.edit_text(f"❌ Erro inesperado ao baixar o vídeo: {error_message}")
    finally:
        if 'temp_dir' in locals() and os.path.exists(temp_dir):
            shutil.rmtree(temp_dir)