ytsage_gui_video_info.py

import sys
import os
import webbrowser
from PySide6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout,
                            QHBoxLayout, QLineEdit, QPushButton, QTableWidget,
                            QTableWidgetItem, QProgressBar, QLabel, QFileDialog,
                            QHeaderView, QStyle, QStyleFactory, QComboBox, QTextEdit, QDialog, QPlainTextEdit, QCheckBox, QButtonGroup)
from PySide6.QtCore import Qt, Signal, QObject, QThread
from PySide6.QtGui import QIcon, QPalette, QColor, QPixmap
import requests
from io import BytesIO
from PIL import Image
from datetime import datetime
import json
from pathlib import Path
from packaging import version
import subprocess
import re
import yt_dlp

class VideoInfoMixin:
    def setup_video_info_section(self):
        # Create a horizontal layout for thumbnail and video info
        media_info_layout = QHBoxLayout()
        media_info_layout.setSpacing(15)

        # Left side container for thumbnail
        thumbnail_container = QWidget()
        thumbnail_container.setFixedWidth(320)
        thumbnail_layout = QVBoxLayout(thumbnail_container)
        thumbnail_layout.setContentsMargins(0, 0, 0, 0)
        
        # Thumbnail on the left
        self.thumbnail_label = QLabel()
        self.thumbnail_label.setFixedSize(320, 180)
        self.thumbnail_label.setStyleSheet("border: 2px solid #3d3d3d; border-radius: 4px;")
        self.thumbnail_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        thumbnail_layout.addWidget(self.thumbnail_label)
        thumbnail_layout.addStretch()
        
        media_info_layout.addWidget(thumbnail_container)

        # Video information on the right
        video_info_layout = QVBoxLayout()
        video_info_layout.setSpacing(2)  # Reduce spacing between elements
        video_info_layout.setAlignment(Qt.AlignmentFlag.AlignTop)
        
        # Title and info labels
        self.title_label = QLabel()
        self.title_label.setWordWrap(True)
        self.title_label.setStyleSheet("font-size: 14px; font-weight: bold;")

        # Add basic info labels
        self.channel_label = QLabel()
        self.views_label = QLabel()
        self.date_label = QLabel()
        self.duration_label = QLabel()

        # Style the info labels
        for label in [self.channel_label, self.views_label, self.date_label, self.duration_label]:
            label.setStyleSheet("""
                QLabel {
                    color: #cccccc;
                    font-size: 12px;
                    padding: 1px 0;
                }
            """)

        # Add labels to video info layout
        video_info_layout.addWidget(self.title_label)
        video_info_layout.addWidget(self.channel_label)
        video_info_layout.addWidget(self.views_label)
        video_info_layout.addWidget(self.date_label)
        video_info_layout.addWidget(self.duration_label)

        # Add spacing before subtitle section
        video_info_layout.addSpacing(10)

        # Create a horizontal layout for subtitle controls
        subtitle_layout = QHBoxLayout()
        subtitle_layout.setSpacing(5)  # Reduce spacing between elements

        # Create subtitle button
        self.subtitle_check = QPushButton("Download Subtitles")
        self.subtitle_check.setFixedHeight(30)
        self.subtitle_check.setFixedWidth(150)  # Set fixed width
        self.subtitle_check.setCheckable(True)
        self.subtitle_check.clicked.connect(self.toggle_subtitle_controls)
        self.subtitle_check.setStyleSheet("""
            QPushButton {
                background-color: #363636;
                border: 2px solid #3d3d3d;
                border-radius: 4px;
                padding: 5px;
                min-height: 30px;
            }
            QPushButton:checked {
                background-color: #ff0000;
                border-color: #cc0000;
            }
        """)
        subtitle_layout.addWidget(self.subtitle_check)

        # Create subtitle combo box
        self.subtitle_combo = QComboBox()
        self.subtitle_combo.setFixedHeight(30)
        self.subtitle_combo.setFixedWidth(200)
        self.subtitle_combo.setVisible(False)
        self.subtitle_combo.setStyleSheet("""
            QComboBox {
                background-color: #363636;
                border: 2px solid #3d3d3d;
                border-radius: 4px;
                padding: 5px;
                min-height: 30px;
            }
        """)
        subtitle_layout.addWidget(self.subtitle_combo)

        # Create merge subtitles checkbox
        self.merge_subs_checkbox = QCheckBox("Merge Subtitles")
        self.merge_subs_checkbox.setFixedHeight(30)
        self.merge_subs_checkbox.setVisible(False)
        self.merge_subs_checkbox.setStyleSheet("""
            QCheckBox {
                color: #ffffff;
                padding: 5px;
                margin-left: 10px;
            }
            QCheckBox::indicator {
                width: 18px;
                height: 18px;
                border-radius: 9px;
            }
            QCheckBox::indicator:unchecked {
                border: 2px solid #666666;
                background: #2b2b2b;
                border-radius: 9px;
            }
            QCheckBox::indicator:checked {
                border: 2px solid #ff0000;
                background: #ff0000;
                border-radius: 9px;
            }
        """)
        subtitle_layout.addWidget(self.merge_subs_checkbox)

        # Add stretch to push everything to the left
        subtitle_layout.addStretch()

        # Create a second row for the filter input
        filter_layout = QHBoxLayout()
        filter_layout.setSpacing(5)

        # Create subtitle filter input
        self.subtitle_filter_input = QLineEdit()
        self.subtitle_filter_input.setFixedHeight(30)
        self.subtitle_filter_input.setFixedWidth(200)
        self.subtitle_filter_input.setPlaceholderText("Filter languages (e.g., en, es)")
        self.subtitle_filter_input.textChanged.connect(self.filter_subtitles)
        self.subtitle_filter_input.setVisible(False)
        self.subtitle_filter_input.setStyleSheet("""
            QLineEdit {
                background-color: #363636;
                border: 2px solid #3d3d3d;
                border-radius: 4px;
                padding: 5px;
                min-height: 30px;
                color: white;
            }
            QLineEdit:focus {
                border-color: #ff0000;
            }
        """)
        filter_layout.addWidget(self.subtitle_filter_input)
        filter_layout.addStretch()

        # Add both layouts to video info
        video_info_layout.addLayout(subtitle_layout)
        video_info_layout.addLayout(filter_layout)
        
        # Add stretch at the bottom
        video_info_layout.addStretch()

        # Add video info layout to main layout
        media_info_layout.addLayout(video_info_layout, stretch=1)

        return media_info_layout

    def setup_playlist_info_section(self):
        self.playlist_info_label = QLabel()
        self.playlist_info_label.setVisible(False)
        self.playlist_info_label.setStyleSheet("""
            QLabel {
                font-size: 12px;
                color: #ff9900;
                padding: 5px 8px;
                margin: 0;
                background-color: #2b2b2b;
                border: 1px solid #3d3d3d;
                border-radius: 4px;
                min-height: 30px;
                max-height: 30px;
            }
        """)
        self.playlist_info_label.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
        return self.playlist_info_label

    def update_video_info(self, info):
        # Format view count with commas
        views = int(info.get('view_count', 0))
        formatted_views = f"{views:,}"

        # Format upload date
        upload_date = info.get('upload_date', '')
        if upload_date:
            date_obj = datetime.strptime(upload_date, '%Y%m%d')
            formatted_date = date_obj.strftime('%B %d, %Y')
        else:
            formatted_date = 'Unknown date'

        # Format duration
        duration = info.get('duration', 0)
        minutes = duration // 60
        seconds = duration % 60
        duration_str = f"{minutes}:{seconds:02d}"

        # Update labels
        self.title_label.setText(info.get('title', 'Unknown title'))
        self.channel_label.setText(f"Channel: {info.get('uploader', 'Unknown channel')}")
        self.views_label.setText(f"Views: {formatted_views}")
        self.date_label.setText(f"Upload date: {formatted_date}")
        self.duration_label.setText(f"Duration: {duration_str}")

    def toggle_subtitle_controls(self):
        is_checked = self.subtitle_check.isChecked()
        self.subtitle_combo.setVisible(is_checked)
        self.subtitle_filter_input.setVisible(is_checked)
        self.merge_subs_checkbox.setVisible(is_checked)

    def update_subtitle_list(self):
        self.subtitle_combo.clear()

        if not (self.available_subtitles or self.available_automatic_subtitles):
            self.subtitle_combo.addItem("No subtitles available")
            return

        # Add subtitle options
        self.subtitle_combo.addItem("Select subtitle language")

        # Filter and add subtitles
        filter_text = self.subtitle_filter_input.text().lower()

        # Add manual subtitles
        for lang_code, subtitle_info in self.available_subtitles.items():
            if not filter_text or filter_text in lang_code.lower():
                self.subtitle_combo.addItem(f"{lang_code} - Manual")

        # Add auto-generated subtitles
        for lang_code, subtitle_info in self.available_automatic_subtitles.items():
            if not filter_text or filter_text in lang_code.lower():
                self.subtitle_combo.addItem(f"{lang_code} - Auto-generated")

    def filter_subtitles(self):
        self.subtitle_filter = self.subtitle_filter_input.text()
        self.update_subtitle_list()

    def download_thumbnail(self, url):
        try:
            # Store both thumbnail URL and video URL
            self.thumbnail_url = url
            self.video_url = self.url_input.text()  # Get actual video URL

            # Download thumbnail but don't save yet
            response = requests.get(url)
            self.thumbnail_image = Image.open(BytesIO(response.content))

            # Display thumbnail
            image = self.thumbnail_image.resize((320, 180), Image.Resampling.LANCZOS)
            img_byte_arr = BytesIO()
            image.save(img_byte_arr, format='PNG')
            pixmap = QPixmap()
            pixmap.loadFromData(img_byte_arr.getvalue())
            self.thumbnail_label.setPixmap(pixmap)
        except Exception as e:
            print(f"Error loading thumbnail: {str(e)}")

    def toggle_save_thumbnail(self):
        self.save_thumbnail = self.save_thumbnail_checkbox.isChecked()
        print(f"Save thumbnail toggled: {self.save_thumbnail}")  # Debug print

    def download_thumbnail_file(self, video_url, path):
        if not self.save_thumbnail:
            return False

        try:
            from yt_dlp import YoutubeDL
            import requests  # Use requests instead of urlopen

            print(f"Attempting to save thumbnail for URL: {video_url}")

            ydl_opts = {
                'quiet': True,
                'skip_download': True,
                'force_generic_extractor': False,
                'no_warnings': True,
                'extract_flat': False
            }

            with YoutubeDL(ydl_opts) as ydl:
                info = ydl.extract_info(video_url, download=False)
                thumbnails = info.get('thumbnails', [])

                if not thumbnails:
                    raise ValueError("No thumbnails available")

                thumbnail_url = max(
                    thumbnails,
                    key=lambda t: (t.get('height', 0) or 0) * (t.get('width', 0) or 0)
                ).get('url')

                if not thumbnail_url:
                    raise ValueError("Failed to extract thumbnail URL")

                # Download using requests
                response = requests.get(thumbnail_url)
                response.raise_for_status()

                # Save the thumbnail
                thumb_dir = os.path.join(path, 'Thumbnails')
                os.makedirs(thumb_dir, exist_ok=True)

                filename = f"{self.sanitize_filename(info['title'])}.jpg"
                thumbnail_path = os.path.join(thumb_dir, filename)

                with open(thumbnail_path, 'wb') as f:
                    f.write(response.content)

                print(f"Thumbnail saved to: {thumbnail_path}")
                self.signals.update_status.emit(f"✅ Thumbnail saved: {filename}")
                return True

        except Exception as e:
            error_msg = f"❌ Thumbnail error: {str(e)}"
            print(f"Thumbnail Save Error: {str(e)}")
            self.signals.update_status.emit(error_msg)
            return False

    def sanitize_filename(self, name):
        """Clean filename for filesystem safety"""
        return re.sub(r'[\\/*?:"<>|]', "", name).strip()[:75]