# Já instaladas no projeto:
pip install yt-dlp
pip install PyQt6

# Certificar que FFmpeg está instalado no sistema
# Windows: baixar de https://ffmpeg.org/download.html
# Linux: sudo apt install ffmpeg
# Mac: brew install ffmpeg

# -*- coding: utf-8 -*-
"""
Video Downloader Module: Handles video downloads with multiple resolutions.
"""

import logging
import os
from typing import Dict, List, Optional, Any, Callable
import yt_dlp
from pathlib import Path

logger = logging.getLogger(__name__)

class VideoDownloader:
    """Gerencia downloads de vídeos com suporte a múltiplas resoluções."""
    
    def __init__(self):
        self.ydl = None
        self._setup_directories()
    
    def _setup_directories(self):
        """Cria diretórios necessários para downloads."""
        self.download_dir = Path.home() / "YouBrief_Downloads"
        self.download_dir.mkdir(exist_ok=True)
    
    def get_available_formats(self, url: str) -> List[Dict[str, Any]]:
        """
        Obtém lista de formatos disponíveis para um vídeo.
        
        Args:
            url: URL do vídeo
            
        Returns:
            Lista de dicionários com informações dos formatos
        """
        ydl_opts = {
            'quiet': True,
            'no_warnings': True,
            'extract_flat': False,
        }
        
        try:
            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
                info = ydl.extract_info(url, download=False)
                
                # Processar formatos disponíveis
                formats = []
                for f in info.get('formats', []):
                    if f.get('vcodec') != 'none':  # Apenas formatos com vídeo
                        format_info = {
                            'format_id': f.get('format_id'),
                            'ext': f.get('ext'),
                            'resolution': f.get('resolution', 'N/A'),
                            'height': f.get('height', 0),
                            'width': f.get('width', 0),
                            'fps': f.get('fps', 0),
                            'filesize': f.get('filesize', 0),
                            'vcodec': f.get('vcodec'),
                            'acodec': f.get('acodec'),
                            'format_note': f.get('format_note', ''),
                            'quality': f.get('quality', 0),
                            'has_audio': f.get('acodec') != 'none'
                        }
                        formats.append(format_info)
                
                # Adicionar formato "best" combinado
                formats.append({
                    'format_id': 'bestvideo+bestaudio',
                    'ext': 'mp4',
                    'resolution': 'Best Available',
                    'format_note': 'Best video + audio (recommended)',
                    'quality': 9999,
                    'has_audio': True
                })
                
                # Ordenar por qualidade (maior primeiro)
                formats.sort(key=lambda x: (x.get('height', 0), x.get('quality', 0)), reverse=True)
                
                return formats
                
        except Exception as e:
            logger.error(f"Erro ao obter formatos: {e}")
            return []
    
    def download_video(self, 
                      url: str, 
                      format_id: str,
                      output_path: Optional[str] = None,
                      progress_callback: Optional[Callable] = None) -> Dict[str, Any]:
        """
        Baixa vídeo no formato especificado.
        
        Args:
            url: URL do vídeo
            format_id: ID do formato a baixar
            output_path: Caminho de saída (opcional)
            progress_callback: Função callback para progresso
            
        Returns:
            Dicionário com informações do download
        """
        if not output_path:
            output_path = str(self.download_dir / '%(title)s.%(ext)s')
        
        def progress_hook(d):
            if progress_callback:
                if d['status'] == 'downloading':
                    total = d.get('total_bytes', 0) or d.get('total_bytes_estimate', 0)
                    downloaded = d.get('downloaded_bytes', 0)
                    speed = d.get('speed', 0)
                    eta = d.get('eta', 0)
                    
                    if total > 0:
                        percent = (downloaded / total) * 100
                        progress_callback({
                            'status': 'downloading',
                            'percent': percent,
                            'downloaded': downloaded,
                            'total': total,
                            'speed': speed,
                            'eta': eta
                        })
                elif d['status'] == 'finished':
                    progress_callback({
                        'status': 'finished',
                        'filename': d.get('filename')
                    })
        
        ydl_opts = {
            'format': format_id,
            'outtmpl': output_path,
            'progress_hooks': [progress_hook],
            'merge_output_format': 'mp4',  # Formato de saída após merge
            'postprocessors': [{
                'key': 'FFmpegVideoConvertor',
                'preferedformat': 'mp4',
            }] if format_id == 'bestvideo+bestaudio' else []
        }
        
        try:
            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
                info = ydl.extract_info(url, download=True)
                return {
                    'success': True,
                    'title': info.get('title'),
                    'filename': ydl.prepare_filename(info),
                    'format': format_id
                }
        except Exception as e:
            logger.error(f"Erro no download: {e}")
            return {
                'success': False,
                'error': str(e)
            }

# -*- coding: utf-8 -*-
"""
Video Download Dialog: Interface para download de vídeos.
"""

from PyQt6.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout, QLabel, 
                            QPushButton, QComboBox, QProgressBar, QGroupBox,
                            QTableWidget, QTableWidgetItem, QHeaderView,
                            QFileDialog, QMessageBox, QLineEdit)
from PyQt6.QtCore import QThread, pyqtSignal, Qt
from PyQt6.QtGui import QFont
from .video_downloader import VideoDownloader

class DownloadWorker(QThread):
    """Thread worker para download de vídeos."""
    progress = pyqtSignal(dict)
    finished = pyqtSignal(dict)
    error = pyqtSignal(str)
    
    def __init__(self, url: str, format_id: str, output_path: str):
        super().__init__()
        self.url = url
        self.format_id = format_id
        self.output_path = output_path
        self.downloader = VideoDownloader()
    
    def run(self):
        try:
            result = self.downloader.download_video(
                self.url,
                self.format_id,
                self.output_path,
                self._progress_callback
            )
            
            if result['success']:
                self.finished.emit(result)
            else:
                self.error.emit(result.get('error', 'Unknown error'))
                
        except Exception as e:
            self.error.emit(str(e))
    
    def _progress_callback(self, data):
        self.progress.emit(data)

class VideoDownloadDialog(QDialog):
    """Diálogo para download de vídeos com seleção de formato."""
    
    def __init__(self, url: str, parent=None):
        super().__init__(parent)
        self.url = url
        self.downloader = VideoDownloader()
        self.download_thread = None
        self.formats = []
        self.initUI()
        self.load_formats()
    
    def initUI(self):
        """Inicializa a interface do usuário."""
        self.setWindowTitle('📥 Download de Vídeo - YouBrief')
        self.setMinimumWidth(700)
        self.setMinimumHeight(500)
        
        layout = QVBoxLayout()
        
        # URL Display
        url_group = QGroupBox("🔗 URL do Vídeo")
        url_layout = QHBoxLayout()
        url_label = QLabel(self.url[:80] + "..." if len(self.url) > 80 else self.url)
        url_label.setWordWrap(True)
        url_layout.addWidget(url_label)
        url_group.setLayout(url_layout)
        layout.addWidget(url_group)
        
        # Formats Table
        formats_group = QGroupBox("📹 Formatos Disponíveis")
        formats_layout = QVBoxLayout()
        
        self.formats_table = QTableWidget()
        self.formats_table.setColumnCount(6)
        self.formats_table.setHorizontalHeaderLabels([
            "Resolução", "Formato", "Codec", "FPS", "Tamanho", "Áudio"
        ])
        self.formats_table.horizontalHeader().setStretchLastSection(True)
        self.formats_table.setSelectionBehavior(QTableWidget.SelectionBehavior.SelectRows)
        self.formats_table.itemSelectionChanged.connect(self.on_format_selected)
        
        formats_layout.addWidget(self.formats_table)
        formats_group.setLayout(formats_layout)
        layout.addWidget(formats_group)
        
        # Output Settings
        output_group = QGroupBox("💾 Configurações de Saída")
        output_layout = QHBoxLayout()
        
        self.output_path = QLineEdit()
        self.output_path.setPlaceholderText("Caminho de saída...")
        
        self.browse_button = QPushButton("📁 Procurar")
        self.browse_button.clicked.connect(self.browse_output_path)
        
        output_layout.addWidget(QLabel("Salvar em:"))
        output_layout.addWidget(self.output_path)
        output_layout.addWidget(self.browse_button)
        
        output_group.setLayout(output_layout)
        layout.addWidget(output_group)
        
        # Progress Bar
        self.progress_bar = QProgressBar()
        self.progress_bar.setVisible(False)
        layout.addWidget(self.progress_bar)
        
        # Status Label
        self.status_label = QLabel("Selecione um formato para download")
        self.status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        layout.addWidget(self.status_label)
        
        # Buttons
        button_layout = QHBoxLayout()
        
        self.download_button = QPushButton("⬇️ Baixar")
        self.download_button.clicked.connect(self.start_download)
        self.download_button.setEnabled(False)
        
        self.cancel_button = QPushButton("❌ Cancelar")
        self.cancel_button.clicked.connect(self.reject)
        
        button_layout.addWidget(self.download_button)
        button_layout.addWidget(self.cancel_button)
        
        layout.addLayout(button_layout)
        self.setLayout(layout)
    
    def load_formats(self):
        """Carrega formatos disponíveis."""
        self.status_label.setText("🔍 Carregando formatos disponíveis...")
        self.formats = self.downloader.get_available_formats(self.url)
        
        if not self.formats:
            self.status_label.setText("❌ Erro ao carregar formatos")
            return
        
        # Preencher tabela
        self.formats_table.setRowCount(len(self.formats))
        
        for i, fmt in enumerate(self.formats):
            # Resolução
            resolution_item = QTableWidgetItem(fmt.get('resolution', 'N/A'))
            resolution_item.setData(Qt.ItemDataRole.UserRole, fmt)
            self.formats_table.setItem(i, 0, resolution_item)
            
            # Formato
            ext = fmt.get('ext', 'N/A')
            self.formats_table.setItem(i, 1, QTableWidgetItem(ext))
            
            # Codec
            vcodec = fmt.get('vcodec', 'N/A')
            if vcodec and vcodec != 'none':
                vcodec = vcodec.split('.')[0]  # Simplificar nome do codec
            self.formats_table.setItem(i, 2, QTableWidgetItem(vcodec))
            
            # FPS
            fps = fmt.get('fps', 0)
            fps_text = f"{fps}" if fps else "N/A"
            self.formats_table.setItem(i, 3, QTableWidgetItem(fps_text))
            
            # Tamanho
            filesize = fmt.get('filesize', 0)
            if filesize:
                size_mb = filesize / (1024 * 1024)
                size_text = f"{size_mb:.1f} MB"
            else:
                size_text = "N/A"
            self.formats_table.setItem(i, 4, QTableWidgetItem(size_text))
            
            # Áudio
            has_audio = "✅" if fmt.get('has_audio') else "❌"
            self.formats_table.setItem(i, 5, QTableWidgetItem(has_audio))
        
        # Ajustar colunas
        self.formats_table.resizeColumnsToContents()
        
        # Selecionar primeiro formato (best)
        if self.formats:
            self.formats_table.selectRow(0)
        
        self.status_label.setText("✅ Formatos carregados. Selecione um para download.")
    
    def on_format_selected(self):
        """Callback quando um formato é selecionado."""
        self.download_button.setEnabled(True)
    
    def browse_output_path(self):
        """Abre diálogo para selecionar pasta de saída."""
        folder = QFileDialog.getExistingDirectory(
            self, "Selecione a pasta de destino"
        )
        if folder:
            self.output_path.setText(folder)
    
    def start_download(self):
        """Inicia o download do vídeo."""
        selected_items = self.formats_table.selectedItems()
        if not selected_items:
            return
        
        # Obter formato selecionado
        selected_row = selected_items[0].row()
        format_data = self.formats[selected_row]
        format_id = format_data['format_id']
        
        # Configurar caminho de saída
        output_dir = self.output_path.text() or str(self.downloader.download_dir)
        output_template = os.path.join(output_dir, '%(title)s.%(ext)s')
        
        # Desabilitar controles
        self.download_button.setEnabled(False)
        self.formats_table.setEnabled(False)
        self.browse_button.setEnabled(False)
        
        # Mostrar progress bar
        self.progress_bar.setVisible(True)
        self.progress_bar.setValue(0)
        
        # Criar e iniciar thread de download
        self.download_thread = DownloadWorker(self.url, format_id, output_template)
        self.download_thread.progress.connect(self.update_progress)
        self.download_thread.finished.connect(self.download_finished)
        self.download_thread.error.connect(self.download_error)
        self.download_thread.start()
        
        self.status_label.setText("📥 Baixando vídeo...")
    
    def update_progress(self, data):
        """Atualiza progresso do download."""
        if data['status'] == 'downloading':
            percent = data.get('percent', 0)
            self.progress_bar.setValue(int(percent))
            
            speed = data.get('speed', 0)
            if speed:
                speed_mb = speed / (1024 * 1024)
                eta = data.get('eta', 0)
                self.status_label.setText(
                    f"📥 Baixando... {percent:.1f}% - "
                    f"Velocidade: {speed_mb:.1f} MB/s - "
                    f"Tempo restante: {eta}s"
                )
    
    def download_finished(self, result):
        """Callback quando download termina."""
        self.progress_bar.setValue(100)
        self.status_label.setText("✅ Download concluído!")
        
        QMessageBox.information(
            self,
            "Download Concluído",
            f"Vídeo baixado com sucesso!\n\n"
            f"Título: {result.get('title', 'N/A')}\n"
            f"Arquivo: {result.get('filename', 'N/A')}"
        )
        
        self.accept()
    
    def download_error(self, error):
        """Callback para erros de download."""
        self.progress_bar.setVisible(False)
        self.status_label.setText(f"❌ Erro: {error}")
        
        QMessageBox.critical(
            self,
            "Erro no Download",
            f"Ocorreu um erro durante o download:\n\n{error}"
        )
        
        # Reabilitar controles
        self.download_button.setEnabled(True)
        self.formats_table.setEnabled(True)
        self.browse_button.setEnabled(True)

# Adicionar no método initUI() da classe MainWindow:

# Botão de Download de Vídeo (após o botão de processar)
self.download_video_button = QPushButton('📥 Baixar Vídeo')
self.download_video_button.setFont(QFont('Arial', 11, QFont.Weight.Bold))
self.download_video_button.clicked.connect(self.open_video_download)
self.download_video_button.setToolTip("Baixar vídeo em diferentes resoluções")

url_input_layout.addWidget(self.download_video_button)

# Adicionar método para abrir diálogo de download:
def open_video_download(self):
    """Abre diálogo para download de vídeo."""
    url = self.url_input.text().strip()
    if not url:
        QMessageBox.warning(
            self, "Aviso", 
            "Por favor, insira uma URL válida do YouTube."
        )
        return
    
    # Validar URL
    from .core import clean_url
    cleaned_url = clean_url(url)
    if not cleaned_url:
        QMessageBox.warning(
            self, "URL Inválida",
            "A URL fornecida não é válida."
        )
        return
    
    try:
        from .video_download_dialog import VideoDownloadDialog
        
        dialog = VideoDownloadDialog(cleaned_url, self)
        dialog.exec()
        
    except Exception as e:
        QMessageBox.critical(
            self, "Erro",
            f"Erro ao abrir download de vídeo:\n{e}"
        )

def create_download_tab(self) -> QWidget:
    """Cria aba de configurações de download."""
    tab = QWidget()
    layout = QVBoxLayout()
    
    # Download Settings
    download_group = QGroupBox("📥 Configurações de Download")
    download_layout = QFormLayout()
    
    # Pasta padrão
    self.default_download_path = QLineEdit()
    browse_btn = QPushButton("📁 Procurar")
    browse_btn.clicked.connect(self.browse_download_folder)
    
    path_layout = QHBoxLayout()
    path_layout.addWidget(self.default_download_path)
    path_layout.addWidget(browse_btn)
    download_layout.addRow("Pasta Padrão:", path_layout)
    
    # Formato preferido
    self.preferred_format = QComboBox()
    self.preferred_format.addItems([
        "Best (Vídeo + Áudio)",
        "1080p",
        "720p", 
        "480p",
        "360p"
    ])
    download_layout.addRow("Formato Preferido:", self.preferred_format)
    
    # Opções avançadas
    self.merge_format = QCheckBox("Mesclar vídeo e áudio automaticamente")
    self.merge_format.setChecked(True)
    download_layout.addRow("", self.merge_format)
    
    self.keep_original = QCheckBox("Manter arquivos originais após mesclar")
    download_layout.addRow("", self.keep_original)
    
    self.subtitle_download = QCheckBox("Baixar legendas quando disponíveis")
    download_layout.addRow("", self.subtitle_download)
    
    download_group.setLayout(download_layout)
    layout.addWidget(download_group)
    
    # Limites de Download
    limits_group = QGroupBox("⚙️ Limites e Performance")
    limits_layout = QFormLayout()
    
    # Limite de velocidade
    self.speed_limit = QSpinBox()
    self.speed_limit.setRange(0, 10000)
    self.speed_limit.setValue(0)
    self.speed_limit.setSuffix(" KB/s (0 = ilimitado)")
    limits_layout.addRow("Limite de Velocidade:", self.speed_limit)
    
    # Conexões simultâneas
    self.concurrent_fragments = QSpinBox()
    self.concurrent_fragments.setRange(1, 10)
    self.concurrent_fragments.setValue(3)
    limits_layout.addRow("Fragmentos Simultâneos:", self.concurrent_fragments)
    
    limits_group.setLayout(limits_layout)
    layout.addWidget(limits_group)
    
    layout.addStretch()
    tab.setLayout(layout)
    return tab

class BatchDownloadDialog(QDialog):
    """Diálogo para download em lote de múltiplos vídeos."""
    
    def __init__(self, parent=None):
        super().__init__(parent)
        self.urls = []
        self.initUI()
    
    # ... implementação do diálogo de lote

class DownloadHistory:
    """Gerencia histórico de downloads."""
    
    def __init__(self):
        self.history_file = Path.home() / ".youbrief" / "download_history.json"
        self.history_file.parent.mkdir(exist_ok=True)
    
    def add_download(self, info: Dict[str, Any]):
        """Adiciona download ao histórico."""
        # ... implementação
    
    def get_history(self, limit: int = 100) -> List[Dict[str, Any]]:
        """Retorna histórico de downloads."""
        # ... implementação

def download_and_process(self, url: str, format_id: str):
    """Baixa vídeo e automaticamente processa transcrição."""
    # 1. Baixar vídeo
    result = self.downloader.download_video(url, format_id)
    
    if result['success']:
        # 2. Processar transcrição do vídeo baixado
        video_path = result['filename']
        # ... chamar funções existentes de processamento

class DownloadErrorHandler:
    """Trata erros comuns de download."""
    
    ERROR_MESSAGES = {
        'ERROR: Video unavailable': 'Vídeo não disponível ou privado',
        'ERROR: Private video': 'Este é um vídeo privado',
        'ERROR: This video is DRM protected': 'Vídeo protegido por DRM',
        'ERROR: Geographic restriction': 'Vídeo bloqueado em sua região',
        'ERROR: No video formats found': 'Nenhum formato de vídeo encontrado'
    }
    
    @staticmethod
    def get_user_friendly_error(error: str) -> str:
        """Converte erro técnico em mensagem amigável."""
        for pattern, message in DownloadErrorHandler.ERROR_MESSAGES.items():
            if pattern in str(error):
                return message
        return f"Erro desconhecido: {error}"

def validate_youtube_url(url: str) -> bool:
    """Valida se é uma URL válida do YouTube."""
    patterns = [
        r'(https?://)?(www\.)?(youtube\.com/(watch\?v=|embed/|v/)|youtu\.be/)',
        r'(https?://)?(www\.)?(m\.youtube\.com/watch\?v=)',
        r'(https?://)?(www\.)?(youtube\.com/shorts/)'
    ]
    
    for pattern in patterns:
        if re.match(pattern, url):
            return True
    return False

class FormatCache:
    """Cache para formatos de vídeo já consultados."""
    
    def __init__(self, ttl: int = 3600):
        self.cache = {}
        self.ttl = ttl
    
    def get(self, url: str) -> Optional[List[Dict]]:
        """Obtém formatos do cache se ainda válidos."""
        # ... implementação com TTL

ydl_opts = {
    'continuedl': True,  # Continuar downloads parciais
    'noprogress': False,
    'retries': 10,
    'fragment_retries': 10,
}

import unittest
from video_downloader import VideoDownloader

class TestVideoDownloader(unittest.TestCase):
    def setUp(self):
        self.downloader = VideoDownloader()
    
    def test_get_formats(self):
        # Testar com URL conhecida
        formats = self.downloader.get_available_formats(TEST_URL)
        self.assertGreater(len(formats), 0)
    
    def test_invalid_url(self):
        formats = self.downloader.get_available_formats("invalid_url")
        self.assertEqual(len(formats), 0)

def show_legal_disclaimer(self):
    """Mostra aviso legal antes do primeiro download."""
    QMessageBox.information(
        self,
        "Aviso Legal",
        "Este software deve ser usado apenas para baixar conteúdo:\n\n"
        "• Que você tem permissão para baixar\n"
        "• Para uso pessoal e não comercial\n"
        "• Respeitando os direitos autorais\n\n"
        "O uso indevido é de responsabilidade do usuário."
    )

# Instalar dependências (se necessário)
pip install yt-dlp PyQt6

# Estrutura de arquivos a criar
youbrief/
├── video_downloader.py      # Nova lógica de download
├── video_download_dialog.py  # Nova interface de download
└── gui.py                    # Modificar para integração

# Testar implementação
python -m youbrief.gui

# Executar testes
python -m pytest tests/test_video_downloader.py

# Download com formato automático (melhor qualidade)
python -m core.cli download "https://www.youtube.com/watch?v=ABC123"

# Download com formato específico
python -m core.cli download "https://www.youtube.com/watch?v=ABC123" --format 720p

# Download com pasta personalizada
python -m core.cli download "https://www.youtube.com/watch?v=ABC123" --output ~/Downloads/

# Listar formatos disponíveis
python -m core.cli download "URL" --list-formats

# Download com progresso detalhado
python -m core.cli download "URL" --verbose

# Ajuda
python -m core.cli download --help

# Executar GUI
python -m core

# GUI explícita
python -m core.gui

# Download básico
python -m core.cli download "https://www.youtube.com/watch?v=VIDEO_ID"

# Listar formatos
python -m core.cli download --list-formats "URL"

# Download com formato específico
python -m core.cli download --format "22" "URL"

# Download com pasta personalizada
python -m core.cli download --output ~/Downloads/ "URL"

# Modo verbose
python -m core.cli download --verbose "URL"

# Agora oculta formatos video-only sem áudio
if f.get('acodec') == 'none':
    continue  # Skip video-only formats

ID              Resolução    Ext    Codec     Tamanho    Áudio  Processamento
───────────────────────────────────────────────────────────────────────────
bestvideo+be... Best Ava...  mp4    best      ~180.2MB   ✅     Merge (+tempo)
22              720p         mp4    h264      80.5MB     ✅     Direto
18              360p         mp4    h264      30.2MB     ✅     Direto

💡 Use --format <ID> para baixar um formato específico
💡 Use 'bestvideo+bestaudio' para melhor qualidade
💡 Tamanhos com '~' são estimativas baseadas no bitrate
⚠️  Formatos 'Merge' requerem FFmpeg e levam mais tempo de processamento

# Configuração melhorada para merge
ydl_opts['postprocessors'] = [
    {
        'key': 'FFmpegVideoConvertor',
        'preferedformat': 'mp4',
    },
    {
        'key': 'FFmpegMetadata',
    }
]
ydl_opts['merge_output_format'] = 'mp4'

class FormatLoaderWorker(QThread):
    """Thread worker for loading video formats asynchronously."""
    
    formats_loaded = pyqtSignal(list)
    error_occurred = pyqtSignal(str)
    
    def run(self):
        """Load formats in background thread."""
        formats = self.downloader.get_available_formats(self.url)
        self.formats_loaded.emit(formats)

# Loading indicator (for format loading)
self.loading_progress = QProgressBar()
self.loading_progress.setRange(0, 0)  # Indeterminate progress
self.loading_progress.setFormat("Carregando formatos...")

def on_formats_error(self, error_message):
    """Handle error loading formats."""
    self.status_label.setText("❌ Erro ao carregar formatos")
    self.show_notification(f"Erro ao carregar formatos: {error_message}", "error")
    
    # Show error in table
    error_item = QTableWidgetItem(f"❌ Erro: {error_message}")
    error_item.setFlags(error_item.flags() & ~Qt.ItemFlag.ItemIsSelectable)

def closeEvent(self, event):
    """Handle dialog close event."""
    # Stop format loader thread if running
    if self.format_loader_thread and self.format_loader_thread.isRunning():
        self.format_loader_thread.terminate()
        self.format_loader_thread.wait()

def _generate_detailed_filename(self, video_info: Dict[str, Any], format_info: Dict[str, Any]) -> str:
    """Generate detailed filename with resolution, codec, and method info."""
    title = self._sanitize_filename(video_info.get('title', 'Unknown'))
    
    # Extract format details
    resolution = format_info.get('resolution', 'Unknown')
    if resolution == 'Best Available 🔄':
        resolution = 'BestMerge'
    
    vcodec = format_info.get('vcodec', 'unknown')
    if vcodec == 'best':
        vcodec = 'BestVideo'
    
    method = format_info.get('processing_type', 'Direct')
    if method == 'Merge (+tempo)':
        method = 'Merge'
    
    # Build filename: "Title - Resolution - Codec - Method.ext"
    filename = f"{title} - {resolution} - {vcodec.upper()} - {method}.{ext}"
    return self._sanitize_filename(filename)

def _sanitize_filename(self, filename: str) -> str:
    """Sanitize filename by removing/replacing invalid characters."""
    # Remove invalid characters for Windows/Linux/macOS
    invalid_chars = '<>:"/\\|?*'
    for char in invalid_chars:
        filename = filename.replace(char, '_')
    
    # Remove excessive spaces and dots
    filename = re.sub(r'\s+', ' ', filename.strip())
    filename = re.sub(r'\.+', '.', filename)
    
    # Truncate if too long (Windows limit)
    if len(filename) > 200:
        filename = filename[:200].rstrip()
    
    return filename

# Modified download_video method
def download_video(self, url: str, format_id: str, output_path: Optional[str] = None, 
                  progress_callback: Optional[Callable] = None, 
                  format_info: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
    
    # Generate detailed filename if format_info is provided
    if format_info:
        video_info = self.get_video_info(cleaned_url)
        if video_info:
            detailed_filename = self._generate_detailed_filename(video_info, format_info)
            output_path = str(self.download_dir / detailed_filename)

# CLI automaticamente usa nomes detalhados
python -m core.cli download "https://youtube.com/watch?v=ABC123" --format 22

# Resultado: "Tutorial Python - 720p - H264 - Direct.mp4"

# video_download_dialog.py - update_progress()
logger.info(f"🔍 PROGRESS UPDATE: status={status}, total={total_percent:.2f}%, phase={phase_percent:.2f}%")
logger.info(f"🔍 RAW DATA: {data}")
logger.info(f"🔍 UI STATE: total_bar_visible={self.total_progress_bar.isVisible()}")

# Bypass throttling completamente para 'processing'
if status == 'processing':
    logger.info(f"🚀 BYPASSING THROTTLING for processing status")
    should_update = True

# Detailed logging para cada atualização
logger.info(f"🎯 UPDATING TOTAL BAR: {old_total_value} → {int(total_percent)}")
logger.info(f"🎯 TOTAL BAR AFTER UPDATE: {self.total_progress_bar.value()}")

# video_downloader.py - _ffmpeg_progress_callback()
def _ffmpeg_progress_callback(self, progress_data: Dict[str, Any]):
    # Detailed logging and improved phase integration
    ffmpeg_percent = progress_data.get('percent', 0.0)
    logger.info(f"🔧 FFMPEG CALLBACK: received {ffmpeg_percent:.2f}% progress")
    
    # Update processing phase progress
    old_total = self.phase_manager.total_progress
    self.phase_manager.update_phase_progress('processing', ffmpeg_percent)
    new_total = self.phase_manager.total_progress
    
    logger.info(f"🔧 PHASE MANAGER: processing={ffmpeg_percent:.2f}%, total: {old_total:.2f}% → {new_total:.2f}%")

# ffmpeg_progress.py - _calculate_total_progress()
def _calculate_total_progress(self):
    calculations = []
    for phase, weight in self.phase_weights.items():
        phase_contribution = (self.phase_progress[phase] / 100.0) * weight
        total += phase_contribution
        calculations.append(f"{phase}:{self.phase_progress[phase]:.1f}%*{weight:.1f}={phase_contribution:.3f}")
    
    logger.info(f"📊 PHASE CALCULATION: {' + '.join(calculations)} = {total:.3f} → {self.total_progress:.2f}%")

# Enhanced download to processing transition
elif d['status'] == 'finished':
    logger.info(f"🔄 DOWNLOAD FINISHED - transitioning phases")
    self.phase_manager.finish_phase('download')
    
    requires_processing = (format_id == 'bestvideo+bestaudio' or compression_config.get('enabled', False))
    
    if requires_processing:
        self.phase_manager.set_phase('processing')
        progress_callback({
            'status': 'download_finished',
            'phase': 'processing',
            'total_percent': self.phase_manager.total_progress,
            'phase_name': 'Processamento',
            'percent': 0  # Processing starts at 0%
        })

# FASE 2: Force progress bar updates for processing
if phase_percent > 0:
    logger.info(f"💪 FORCING PROGRESS UPDATE: {phase_percent:.2f}% → bars")
    # Force update phase bar directly
    self.phase_progress_bar.setValue(int(phase_percent))
    # Manual total calculation if needed
    if total_percent == 0 and phase_percent > 0:
        manual_total = 70 + (phase_percent * 0.25)  # Processing is 25% of total, starts at 70%
        logger.info(f"💪 MANUAL TOTAL CALCULATION: {manual_total:.2f}%")
        self.total_progress_bar.setValue(int(manual_total))

# ffmpeg_progress.py - parse_progress_line()
try:
    self.progress_callback(progress_data)
    self.last_progress_percent = progress_percent
    logger.debug(f"⚡ FFmpeg progress callback sent: {progress_percent:.2f}%")
except Exception as e:
    logger.error(f"❌ Error in FFmpeg progress callback: {e}")
    # Continue parsing even if callback fails

# video_downloader.py - _ffmpeg_progress_callback()
try:
    self.phase_manager.progress_callback(enhanced_data)
    logger.info(f"🔧 CALLBACK SENT successfully")
except Exception as e:
    logger.error(f"❌ CALLBACK FAILED: {e}")
    # Fallback - try original callback directly
    if hasattr(self.phase_manager, '_original_callback') and self.phase_manager._original_callback:
        try:
            self.phase_manager._original_callback(enhanced_data)
            logger.info(f"🔧 FALLBACK CALLBACK SUCCESS")
        except Exception as e2:
            logger.error(f"❌ FALLBACK CALLBACK ALSO FAILED: {e2}")

# Safety check - if bars are still 0 after processing started, force update
if status == 'processing' and phase_percent > 10 and self.total_progress_bar.value() == 0:
    logger.warning(f"🚨 SAFETY RECOVERY: Bars at 0% but processing at {phase_percent:.2f}%")
    self.total_progress_bar.setValue(int(70 + phase_percent * 0.25))
    self.phase_progress_bar.setValue(int(phase_percent))
    logger.warning(f"🚨 FORCED UPDATE: total={self.total_progress_bar.value()}%, phase={self.phase_progress_bar.value()}%")