tvs.py

#!/usr/bin/env python3.13
"""
TVS - Text-Video-Summarizer
A standalone tool for downloading, transcribing, and summarizing videos.

Usage:
    python3.13 tvs.py -u <URL>
    python3.13 tvs.py --url <URL>

Example:
    python3.13 tvs.py -u https://youtube.com/watch?v=dQw4w9WgXcQ
"""

import argparse
import subprocess
import sys
import os
import time
import logging
from pathlib import Path
from datetime import datetime

# ============================================================================
# CONFIGURATION
# ============================================================================

# Get the directory where this script is located
SCRIPT_DIR = Path(__file__).parent.resolve()

# Directories (VIDEOS_DIR and LOG_DIR relative to script, WORK_DIR can be overridden)
VIDEOS_DIR = SCRIPT_DIR / "videos"
WORK_DIR = SCRIPT_DIR / "transcripts"
LOG_DIR = SCRIPT_DIR / "logs"


def set_work_dir(output_path):
    """Set custom work directory for transcripts and summaries."""
    global WORK_DIR
    WORK_DIR = Path(output_path).resolve()


# MLX-Whisper transcription configuration
MLX_WHISPER_DIR = Path("/Users/khaled/cc-project/insanely-fast-whisper")
MLX_WHISPER_BIN = MLX_WHISPER_DIR / ".venv" / "bin" / "mlx_whisper"
MLX_WHISPER_MODEL = "mlx-community/distil-whisper-large-v3"

# Cookies directory structure (organized by site)
COOKIES_DIR = SCRIPT_DIR / "cookies"
SITE_COOKIES = {
    "instagram": COOKIES_DIR / "instagram" / "www.instagram.com_cookies.txt",
    "threads": COOKIES_DIR / "threads" / "www.threads.net_cookies.txt",
    "tiktok": COOKIES_DIR / "tiktok" / "www.tiktok.com_cookies.txt",
    "x": COOKIES_DIR / "x" / "x.com_cookies.txt",
    "youtube": COOKIES_DIR / "youtube" / "www.youtube.com_cookies.txt",
}

# Cookie expiration warning threshold (days)
COOKIE_WARNING_DAYS = 30


# Colors for terminal output (opencode-style)
class Colors:
    RED = "\033[91m"
    GREEN = "\033[92m"
    YELLOW = "\033[93m"
    BLUE = "\033[94m"
    MAGENTA = "\033[95m"
    CYAN = "\033[96m"
    WHITE = "\033[97m"
    GRAY = "\033[90m"

    BOLD = "\033[1m"
    DIM = "\033[2m"
    UNDERLINE = "\033[4m"
    RESET = "\033[0m"

    SUCCESS = GREEN
    WARNING = YELLOW
    ERROR = RED
    INFO = CYAN
    HEADER = MAGENTA


# ============================================================================
# UTILITY FUNCTIONS
# ============================================================================


def setup_logging():
    """
    Set up dual logging system:
    1. Debug log - Complete tool execution (all operations, errors, debug info)
    2. Processed files log - Clean history of successfully processed files
    """
    # Create logs directory
    LOG_DIR.mkdir(parents=True, exist_ok=True)

    # Create work directory for transcripts and summaries
    WORK_DIR.mkdir(parents=True, exist_ok=True)

    # Generate log filenames with format: debug-DD-M-YYYY.log and processed-DD-M-YYYY.log
    now = datetime.now()
    date_suffix = f"{now.day}-{now.month}-{now.year}"
    debug_log_file = LOG_DIR / f"debug-{date_suffix}.log"
    processed_log_file = LOG_DIR / f"processed-{date_suffix}.log"

    # Clear any existing handlers
    logger = logging.getLogger()
    logger.handlers.clear()
    logger.setLevel(logging.DEBUG)

    # 1. DEBUG LOG - Verbose logging of all operations
    debug_handler = logging.FileHandler(debug_log_file, mode="a", encoding="utf-8")
    debug_handler.setLevel(logging.DEBUG)
    debug_formatter = logging.Formatter(
        "%(asctime)s - %(levelname)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
    )
    debug_handler.setFormatter(debug_formatter)
    logger.addHandler(debug_handler)

    # 2. PROCESSED FILES LOG - Clean summary handler (only for file processing results)
    # We'll use this separately via a custom logger
    processed_handler = logging.FileHandler(
        processed_log_file, mode="a", encoding="utf-8"
    )
    processed_handler.setLevel(logging.INFO)
    processed_formatter = logging.Formatter(
        "%(asctime)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
    )
    processed_handler.setFormatter(processed_formatter)

    # Create separate logger for processed files
    processed_logger = logging.getLogger("processed")
    processed_logger.handlers.clear()
    processed_logger.setLevel(logging.INFO)
    processed_logger.addHandler(processed_handler)
    processed_logger.propagate = False  # Don't propagate to root logger

    # Log session start in both logs
    logging.info("=" * 60)
    logging.info("TVS SESSION STARTED")
    logging.info("=" * 60)

    processed_logger.info("=" * 60)
    processed_logger.info("SESSION START")
    processed_logger.info("=" * 60)

    return debug_log_file, processed_log_file


def detect_site(url):
    """
    Detect which site a URL is from.

    Args:
        url: Video URL

    Returns:
        str: Site name ('instagram', 'youtube', 'tiktok', 'threads', 'x', or 'other')
    """
    url_lower = url.lower()

    if "instagram.com" in url_lower:
        return "instagram"
    elif "threads.net" in url_lower or "threads.com" in url_lower:
        return "threads"
    elif "tiktok.com" in url_lower:
        return "tiktok"
    elif "x.com" in url_lower or "twitter.com" in url_lower:
        return "x"
    elif "youtube.com" in url_lower or "youtu.be" in url_lower:
        return "youtube"
    else:
        return "other"


def get_site_output_dir(site):
    """
    Get the output directory for a specific site.

    Args:
        site: Site name

    Returns:
        Path: Site-specific subdirectory in VIDEOS_DIR
    """
    site_dir = VIDEOS_DIR / site
    site_dir.mkdir(parents=True, exist_ok=True)
    return site_dir


def check_cookie_age(cookie_file):
    """
    Check if cookie file is older than warning threshold.

    Args:
        cookie_file: Path to cookie file

    Returns:
        tuple: (age_in_days, is_expired_warning)
    """
    if not cookie_file.exists():
        return None, False

    file_time = cookie_file.stat().st_mtime
    age_seconds = time.time() - file_time
    age_days = age_seconds / (24 * 3600)

    is_old = age_days >= COOKIE_WARNING_DAYS

    return int(age_days), is_old


def print_header(text):
    """Print colored header."""
    print(f"\n{Colors.HEADER}{Colors.BOLD}{'=' * 60}{Colors.RESET}")
    print(f"{Colors.HEADER}{Colors.BOLD}{text}{Colors.RESET}")
    print(f"{Colors.HEADER}{Colors.BOLD}{'=' * 60}{Colors.RESET}\n", flush=True)


def print_step(step_num, text):
    """Print step number and description."""
    print(
        f"{Colors.BLUE}{Colors.BOLD}[Step {step_num}]{Colors.RESET} {text}", flush=True
    )


def print_success(text):
    """Print success message."""
    print(f"{Colors.SUCCESS}[+]{Colors.RESET} {text}", flush=True)


def print_error(text):
    """Print error message."""
    print(f"{Colors.ERROR}[-]{Colors.RESET} {text}", flush=True)


def print_warning(text):
    """Print warning message."""
    print(f"{Colors.WARNING}[!]{Colors.RESET} {text}", flush=True)


def print_info(text):
    """Print info message."""
    print(f"{Colors.INFO}[*]{Colors.RESET} {text}", flush=True)


def print_color_demo():
    """Print a demo of all available colors."""
    print(f"\n{Colors.BOLD}{'=' * 60}{Colors.RESET}")
    print(f"{Colors.HEADER}{Colors.BOLD}  TVS Color Demo{Colors.RESET}")
    print(f"{Colors.BOLD}{'=' * 60}{Colors.RESET}\n")

    print(f"{Colors.SUCCESS}[+]{Colors.RESET} Success - Successful operations")
    print(f"{Colors.WARNING}[!]{Colors.RESET} Warning - Warnings and cautions")
    print(f"{Colors.ERROR}[-]{Colors.RESET} Error - Errors and failures")
    print(f"{Colors.INFO}[*]{Colors.RESET} Info - Information messages")
    print(f"{Colors.BLUE}[Step]{Colors.RESET} Step - Step indicators")
    print(f"{Colors.HEADER}[Header]{Colors.RESET} Header - Section headers")
    print(f"{Colors.GRAY}[Dim]{Colors.RESET} Dim - Muted text")
    print(f"{Colors.BOLD}Bold{Colors.RESET} - Emphasis")
    print(f"{Colors.UNDERLINE}Underline{Colors.RESET} - Links/references")
    print(f"{Colors.DIM}Dimmed{Colors.RESET} - Secondary text")
    print(f"\n{Colors.BOLD}Standard Colors:{Colors.RESET}")
    print(
        f"{Colors.RED}Red{Colors.RESET} {Colors.GREEN}Green{Colors.RESET} {Colors.YELLOW}Yellow{Colors.RESET} {Colors.BLUE}Blue{Colors.RESET} {Colors.MAGENTA}Magenta{Colors.RESET} {Colors.CYAN}Cyan{Colors.RESET} {Colors.WHITE}White{Colors.RESET} {Colors.GRAY}Gray{Colors.RESET}"
    )
    print()


def run_command(cmd, cwd=None, timeout=600, shell=False, log_output=True):
    """
    Run shell command and return output.

    Args:
        cmd: Command to run (list or string)
        cwd: Working directory
        timeout: Timeout in seconds (default: 600)
        shell: Run as shell command
        log_output: Log command output to debug log

    Returns:
        tuple: (success: bool, stdout: str, stderr: str)
    """
    cmd_display = cmd if isinstance(cmd, str) else " ".join(cmd)
    logging.debug(f"[CMD] Running: {cmd_display}")

    start_time = time.time()
    try:
        result = subprocess.run(
            cmd,
            cwd=cwd,
            capture_output=True,
            text=True,
            timeout=timeout,
            shell=shell,
        )
        elapsed = time.time() - start_time

        success = result.returncode == 0

        if log_output:
            logging.debug(
                f"[CMD] Return code: {result.returncode} (elapsed: {elapsed:.1f}s)"
            )
            if result.stdout:
                logging.debug(f"[CMD] stdout: {result.stdout[:1000]}")
            if result.stderr:
                logging.debug(f"[CMD] stderr: {result.stderr[:1000]}")
            if not success:
                logging.error(f"[CMD] FAILED: {cmd_display}")
                if result.stdout:
                    logging.error(f"[CMD] Full stdout: {result.stdout}")
                if result.stderr:
                    logging.error(f"[CMD] Full stderr: {result.stderr}")

        return success, result.stdout, result.stderr

    except subprocess.TimeoutExpired as e:
        logging.error(f"[CMD] TIMEOUT after {timeout}s: {cmd_display}")
        return False, "", f"Command timed out after {timeout}s"
    except Exception as e:
        logging.error(f"[CMD] EXCEPTION: {e}")
        return False, "", str(e)


# ============================================================================
# VALIDATION FUNCTIONS
# ============================================================================


def validate_environment():
    """Validate that all required tools and paths exist."""
    print_step(0, "Validating environment...")
    logging.info("Starting environment validation")

    errors = []

    # Check yt-dlp
    logging.debug("Checking for yt-dlp...")
    success, _, _ = run_command(["yt-dlp", "--version"])
    if not success:
        errors.append("yt-dlp not found. Install with: brew install yt-dlp")
        logging.error("yt-dlp not found")
    else:
        print_success("yt-dlp found")
        logging.info("yt-dlp found")

    # Check ffmpeg (needed for audio conversion)
    logging.debug("Checking for ffmpeg...")
    success, _, _ = run_command(["ffmpeg", "-version"])
    if not success:
        errors.append("ffmpeg not found. Install with: brew install ffmpeg")
        logging.error("ffmpeg not found")
    else:
        print_success("ffmpeg found")
        logging.info("ffmpeg found")

    # Check mlx-whisper
    logging.debug("Checking for mlx-whisper...")
    if not MLX_WHISPER_BIN.exists():
        errors.append(f"mlx-whisper not found at: {MLX_WHISPER_BIN}")
        errors.append(
            "Install it in the insanely-fast-whisper repo with: pip install mlx-whisper"
        )
        logging.error(f"mlx-whisper not found at {MLX_WHISPER_BIN}")
    else:
        print_success(f"mlx-whisper found ({MLX_WHISPER_BIN})")
        logging.info(f"mlx-whisper found at {MLX_WHISPER_BIN}")

    # Check mediainfo (optional but recommended)
    logging.debug("Checking for mediainfo...")
    success, _, _ = run_command(["mediainfo", "--version"])
    if not success:
        print_warning(
            "mediainfo not found (optional). Install with: brew install mediainfo"
        )
        print_info(
            "Without mediainfo, timeout estimation for long videos may be inaccurate"
        )
        logging.warning("mediainfo not found (optional)")
    else:
        print_success("mediainfo found")
        logging.info("mediainfo found")

    # Check directories
    logging.debug(f"Creating directories: {VIDEOS_DIR}, {WORK_DIR}")
    VIDEOS_DIR.mkdir(parents=True, exist_ok=True)
    print_success(f"Videos directory: {VIDEOS_DIR}")
    logging.info(f"Videos directory: {VIDEOS_DIR}")

    WORK_DIR.mkdir(parents=True, exist_ok=True)
    print_success(f"Work directory: {WORK_DIR}")
    logging.info(f"Work directory: {WORK_DIR}")

    if errors:
        print_error("Environment validation failed:")
        for error in errors:
            print(f"  • {error}")
            logging.error(f"Validation error: {error}")
        logging.error("Environment validation FAILED")
        return False

    print_success("Environment validation passed")
    logging.info("Environment validation PASSED")
    return True


# ============================================================================
# MAIN PROCESSING FUNCTIONS
# ============================================================================


def download_video(url, audio_only=False):
    """
    Download video from URL using yt-dlp.

    Args:
        url: Video URL
        audio_only: If True, download only audio (much smaller)

    Returns:
        tuple: (Path to video file or None, bool indicating if already existed, site name)
    """
    logging.info(f"[DOWNLOAD] Starting download - URL: {url}, audio_only: {audio_only}")

    if audio_only:
        print_step(1, "Downloading audio only...")
        print_info("Mode: Audio-only (faster, smaller file)")
    else:
        print_step(1, "Downloading video...")

    print_info(f"URL: {url}")

    # Detect site and get site-specific directory
    site = detect_site(url)
    print_info(f"Detected site: {site}")
    logging.debug(f"[DOWNLOAD] Detected site: {site}")

    site_dir = get_site_output_dir(site)
    print_info(f"Output directory: {site_dir}")

    # Get list of video/audio files before download
    video_extensions = {
        ".mp4",
        ".webm",
        ".mkv",
        ".avi",
        ".mov",
        ".flv",
        ".wmv",
        ".m4v",
        ".m4a",
        ".opus",
    }
    videos_before = {
        f.name for f in site_dir.glob("*") if f.suffix.lower() in video_extensions
    }

    # Determine filename pattern based on platform
    # Instagram/Threads/TikTok: use ID + description (if available)
    # YouTube: use title (more descriptive)
    if site in ["instagram", "threads", "tiktok"]:
        # Try to get description/caption, fall back to ID
        filename_pattern = "%(id)s.%(ext)s"
    else:
        filename_pattern = "%(title)s.%(ext)s"

    # Check for site-specific cookies file
    use_cookies = False
    cookie_file = SITE_COOKIES.get(site)

    if cookie_file and cookie_file.exists():
        use_cookies = True
        print_info(f"Using {site} cookies for authentication")

        # Check cookie age and warn if old
        age_days, is_old = check_cookie_age(cookie_file)
        if is_old:
            print_warning(
                f"Cookie file is {age_days} days old (threshold: {COOKIE_WARNING_DAYS} days)"
            )
            print_warning(
                f"[WARN] {Colors.ERROR}COOKIES MAY HAVE EXPIRED - CONSIDER UPDATING{Colors.ENDC}"
            )
            print_info(f"Cookie location: {cookie_file}")
        else:
            print_info(f"Cookie age: {age_days} days (OK)")

    if audio_only:
        # Download only audio (much smaller, faster)
        cmd = [
            "yt-dlp",
            "--restrict-filenames",
            "-f",
            "bestaudio/best",  # Audio only
            "-x",  # Extract audio
            "--audio-format",
            "best",  # Keep best audio format
            "-o",
            filename_pattern,
        ]
        if use_cookies:
            cmd.extend(["--cookies", str(cookie_file)])
        cmd.append(url)
    else:
        # Download video with 480p max quality
        # Prefer https (direct download) over m3u8/HLS (slow segment-by-segment)
        # Fallback chain: https direct -> video+audio merge -> any
        cmd = [
            "yt-dlp",
            "--restrict-filenames",
            "-f",
            "best[protocol=https][height<=480]/bestvideo[height<=480]+bestaudio/best[height<=480]/best",
            "-o",
            filename_pattern,
        ]
        if use_cookies:
            cmd.extend(["--cookies", str(cookie_file)])
        cmd.append(url)

    start_time = time.time()
    logging.debug(f"[DOWNLOAD] Running yt-dlp with timeout=1200s")
    success, stdout, stderr = run_command(
        cmd, cwd=site_dir, timeout=1200
    )
    elapsed = time.time() - start_time

    if not success:
        print_error("Download failed")
        print(f"Error: {stderr[:500]}")
        logging.error(f"[DOWNLOAD] Failed after {elapsed:.1f}s")
        logging.error(f"[DOWNLOAD] Full stderr: {stderr}")
        logging.error(f"[DOWNLOAD] Full stdout: {stdout}")

        # Special error handling for unsupported sites
        if site == "threads" and "Unsupported URL" in stderr:
            print_warning("Threads is not yet supported by yt-dlp")
            print_info(
                "Threads support is in development. Check yt-dlp updates: yt-dlp -U"
            )
            print_info(
                "Alternative: Download manually and use the transcript/summary features"
            )
            logging.warning(f"[DOWNLOAD] Unsupported site: {site}")

        return None, False, site

    # Find the most recently created VIDEO file in site directory
    try:
        video_files = [
            f for f in site_dir.glob("*") if f.suffix.lower() in video_extensions
        ]

        if not video_files:
            print_error("No video files found after download")
            return None, False, site

        # Sort by modification time and get the most recent
        video_file = sorted(video_files, key=lambda p: p.stat().st_mtime, reverse=True)[
            0
        ]

        # Normalize filename: remove consecutive dots before extension (e.g. "title..opus" -> "title.opus")
        import os as _os

        name = video_file.name
        ext = video_file.suffix
        base = name[: -len(ext)] if ext else name
        normalized_base = base.rstrip(".")
        if normalized_base != base:
            normalized = video_file.parent / f"{normalized_base}{ext}"
            if normalized.resolve() != video_file.resolve():
                if normalized.exists():
                    normalized.unlink()
                _os.replace(str(video_file), str(normalized))
                video_file = normalized
        file_size = video_file.stat().st_size / (1024**2)  # MB

        # Check if file already existed
        already_existed = video_file.name in videos_before

        if already_existed:
            print_warning(f"Video already exists: {video_file.name}")
            print_info("Skipping download (file already present)")
            logging.info(f"[DOWNLOAD] Skipped (already exists): {video_file.resolve()}")
        else:
            print_success(f"Downloaded: {video_file.name}")
            print_info(f"Time: {elapsed:.1f}s")
            logging.info(
                f"[DOWNLOAD] Success in {elapsed:.1f}s: {video_file.resolve()} ({file_size:.1f} MB)"
            )

        print_info(f"Size: {file_size:.1f} MB")

        return video_file, already_existed, site

    except Exception as e:
        print_error(f"Error finding downloaded file: {e}")
        logging.error(f"[DOWNLOAD] Exception: {e}")
        return None, False, site


def get_video_duration(video_file):
    """
    Get video duration in minutes using mediainfo.

    Args:
        video_file: Path to video file

    Returns:
        int: Duration in minutes, or None if unable to determine
    """
    try:
        # Check if mediainfo is available
        success, _, _ = run_command(["mediainfo", "--version"])
        if not success:
            return None

        # Get duration string from mediainfo
        cmd = ["mediainfo", "--Inform=General;%Duration/String%", str(video_file)]
        success, stdout, stderr = run_command(cmd, timeout=10)

        if not success or not stdout.strip():
            return None

        duration_str = stdout.strip()

        # Parse duration string (examples: "43 min 50 s", "1 h 23 min", "2 min 15 s", "55 s 915 ms")
        total_minutes = 0

        # Extract hours
        if "h" in duration_str:
            hours_part = duration_str.split("h")[0].strip()
            try:
                total_minutes += int(hours_part.split()[-1]) * 60
            except (ValueError, IndexError):
                pass

        # Extract minutes
        if "min" in duration_str:
            # Get the part with minutes
            if "h" in duration_str:
                min_part = duration_str.split("h")[1].split("min")[0].strip()
            else:
                min_part = duration_str.split("min")[0].strip()
            try:
                total_minutes += int(min_part.split()[-1])
            except (ValueError, IndexError):
                pass

        # Handle seconds-only videos (e.g., "55 s 915 ms")
        # If no hours or minutes found, check for seconds and round up to 1 minute
        if total_minutes == 0 and "s" in duration_str and "min" not in duration_str:
            try:
                # Extract seconds (before " s")
                seconds_part = duration_str.split("s")[0].strip()
                seconds = int(seconds_part.split()[-1])
                # Round up to at least 1 minute for short videos
                total_minutes = max(1, (seconds + 59) // 60)  # Round up
            except (ValueError, IndexError):
                pass

        return total_minutes if total_minutes > 0 else None

    except Exception as e:
        print_warning(f"Could not determine video duration: {e}")
        return None


def convert_audio_for_whisper(video_file):
    """
    Convert audio to mono 16kHz WAV for transcription.

    Whisper prefers:
    - Mono channel (not stereo)
    - 16kHz sample rate
    - WAV format preferred

    Args:
        video_file: Path to video/audio file

    Returns:
        Path: Path to converted WAV file, or None on error
    """
    logging.info(f"[CONVERT] Converting audio for whisper: {video_file.name}")

    # Create converted filename
    converted_file = video_file.parent / f"{video_file.stem}_mono16k.wav"

    # Check if already converted
    if converted_file.exists():
        print_info(f"Using existing converted audio: {converted_file.name}")
        logging.info(f"[CONVERT] Using existing: {converted_file}")
        return converted_file

    print_info("Converting audio to mono 16kHz WAV for whisper...")

    # Use ffmpeg to convert: mono, 16kHz, 16-bit PCM WAV
    cmd = [
        "ffmpeg",
        "-i",
        str(video_file),
        "-ac",
        "1",  # Mono
        "-ar",
        "16000",  # 16kHz
        "-acodec",
        "pcm_s16le",  # 16-bit PCM
        "-y",  # Overwrite
        str(converted_file),
    ]

    start_time = time.time()
    success, stdout, stderr = run_command(cmd, timeout=300)

    if not success:
        print_error(f"Audio conversion failed: {stderr[:200]}")
        logging.error(f"[CONVERT] Failed")
        logging.error(f"[CONVERT] Full stderr: {stderr}")
        logging.error(f"[CONVERT] Full stdout: {stdout}")
        return None

    elapsed = time.time() - start_time
    file_size = converted_file.stat().st_size / (1024**2)  # MB

    print_success(f"Converted: {converted_file.name}")
    print_info(f"Size: {file_size:.1f} MB")
    print_info(f"Time: {elapsed:.1f}s")
    logging.info(
        f"[CONVERT] Success in {elapsed:.1f}s: {converted_file} ({file_size:.1f} MB)"
    )

    return converted_file


def _find_whisper_output(video_file):
    """
    Find whisper transcript output file, handling truncated filenames.

    mlx-whisper truncates long filenames (~80 chars). This function tries
    the exact stem match first, then falls back to prefix-based search.

    Args:
        video_file: Path to the video file

    Returns:
        Path to transcript file, or None if not found
    """
    # Try exact match patterns: audio_stem.txt and video_stem.txt
    audio_stem = f"{video_file.stem}_mono16k"
    for stem in [audio_stem, video_file.stem]:
        candidate = video_file.parent / f"{stem}.txt"
        if candidate.exists():
            return candidate

    # Fallback: mlx-whisper truncates long filenames
    # Use first 60 chars as prefix (safe margin before truncation point)
    # Also exclude our own "-transcript.txt" files from results
    prefix = audio_stem[:60]
    txt_files = sorted(
        [
            f
            for f in video_file.parent.glob("*.txt")
            if f.stem.startswith(prefix) and not f.stem.endswith("-transcript")
        ],
        key=lambda p: p.stat().st_mtime,
        reverse=True,
    )
    if txt_files:
        logging.debug(f"[TRANSCRIBE] Whisper truncated filename. Found: {txt_files[0].name}")
        return txt_files[0]

    # Broader fallback: try video stem prefix too
    prefix = video_file.stem[:60]
    txt_files = sorted(
        [
            f
            for f in video_file.parent.glob("*.txt")
            if f.stem.startswith(prefix) and not f.stem.endswith("-transcript")
        ],
        key=lambda p: p.stat().st_mtime,
        reverse=True,
    )
    if txt_files:
        logging.debug(f"[TRANSCRIBE] Found transcript by video stem: {txt_files[0].name}")
        return txt_files[0]

    return None


def transcribe_video(video_file, force=False):
    """
    Transcribe video using mlx-whisper (distil-whisper-large-v3).

    Requires:
    - mlx-whisper installed in the insanely-fast-whisper venv
    - ffmpeg for audio conversion

    Args:
        video_file: Path to video file
        force: Force re-transcription even if transcript exists

    Returns:
        Path: Path to transcript file, or None on error
    """
    logging.info(
        f"[TRANSCRIBE] Starting - Video: {video_file.resolve()}, force: {force}"
    )

    print_step(2, "Transcribing video...")
    print_info(f"Video: {video_file.name}")
    print_info(f"Location: {video_file.parent}")

    # Create transcript filename
    transcript_file = video_file.parent / f"{video_file.stem}-transcript.txt"

    # Check if transcript already exists (also check for whisper-truncated filename)
    if not force:
        existing_transcript = _find_whisper_output(video_file) or (
            transcript_file if transcript_file.exists() else None
        )
        if existing_transcript:
            target = transcript_file if transcript_file.exists() else existing_transcript
            print_warning(f"Transcript already exists: {target.name}")
            print_info("Skipping transcription (file already present)")

            transcript_size = target.stat().st_size
            with open(target, "r") as f:
                transcript_text = f.read()
            word_count = len(transcript_text.split())

            print_info(f"Size: {transcript_size} bytes")
            print_info(f"Words: {word_count}")
            logging.info(
                f"[TRANSCRIBE] Skipped (already exists): {target.resolve()} ({word_count} words)"
            )

            return target

    # Convert audio to mono 16kHz WAV
    converted_audio = convert_audio_for_whisper(video_file)
    if not converted_audio:
        print_error("Failed to convert audio for whisper")
        return None

    audio_path = str(converted_audio.resolve())
    logging.debug(f"[TRANSCRIBE] Audio path: {audio_path}")

    # Build mlx-whisper command
    # mlx-whisper outputs to a .txt file in the output directory
    cmd = [
        str(MLX_WHISPER_BIN),
        audio_path,
        "--model",
        MLX_WHISPER_MODEL,
        "--output-dir",
        str(video_file.parent),
        "--output-format",
        "txt",
    ]

    print_info(f"Using {MLX_WHISPER_MODEL} model...")
    logging.debug(f"[TRANSCRIBE] Running mlx-whisper")

    # Get video duration for timeout
    duration_minutes = get_video_duration(video_file)
    if duration_minutes:
        print_info(f"Duration: {duration_minutes} minutes")
        # Timeout = video duration + 2 minutes buffer
        # Whisper is fast, but we give generous timeout
        timeout = (duration_minutes * 60) + 120
        timeout = max(300, timeout)  # At least 5 minutes
    else:
        timeout = 900  # 15 minutes default if duration unknown

    print_info(f"Transcription timeout: {timeout // 60} minutes {timeout % 60} seconds")

    start_time = time.time()
    success, stdout, stderr = run_command(cmd, timeout=timeout)
    elapsed = time.time() - start_time

    if not success:
        print_error("Transcription failed")
        if stderr:
            print(f"Error: {stderr[-500:]}")
        logging.error(f"[TRANSCRIBE] Failed after {elapsed:.1f}s")
        logging.error(f"[TRANSCRIBE] Full stderr: {stderr}")
        logging.error(f"[TRANSCRIBE] Full stdout: {stdout}")
        logging.error(f"[TRANSCRIBE] Command was: {' '.join(cmd)}")
        print_warning("Troubleshooting:")
        print(f"  1. Ensure mlx-whisper is installed in {MLX_WHISPER_DIR}")
        print(
            f"     cd {MLX_WHISPER_DIR} && source .venv/bin/activate && pip install mlx-whisper"
        )
        print("  2. Check video has audio:")
        print(f"     ffprobe -v error -select_streams a:0 {video_file}")
        return None

    # mlx-whisper creates a .txt file based on the audio filename
    # BUT it truncates long filenames, so we can't rely on exact stem match
    whisper_output_file = _find_whisper_output(video_file)

    if not whisper_output_file:
        print_error(f"Whisper output file not found: {whisper_output_file}")
        logging.error(
            f"[TRANSCRIBE] Whisper output file not found: {whisper_output_file}"
        )
        return None

    # Read transcript from whisper output and write to our expected location
    try:
        transcript_text = whisper_output_file.read_text(encoding="utf-8").strip()
    except Exception as e:
        print_error(f"Failed to read whisper output: {e}")
        logging.error(f"[TRANSCRIBE] Failed to read whisper output: {e}")
        return None

    if not transcript_text:
        print_error("Transcription produced empty output")
        logging.error(f"[TRANSCRIBE] Empty transcript")
        return None

    # Write transcript to expected location
    transcript_file.write_text(transcript_text, encoding="utf-8")

    # Clean up whisper's output file (we've copied it to our expected location)
    try:
        whisper_output_file.unlink()
    except:
        pass

    # Get transcript info
    transcript_size = transcript_file.stat().st_size
    word_count = len(transcript_text.split())

    print_success(f"Transcribed: {transcript_file.name}")
    print_info(f"Size: {transcript_size} bytes")
    print_info(f"Words: {word_count}")
    print_info(f"Time: {elapsed:.1f}s")
    logging.info(
        f"[TRANSCRIBE] Success in {elapsed:.1f}s: {transcript_file.resolve()} ({word_count} words)"
    )

    return transcript_file


def transcribe_file_stt(file_path):
    """
    Standalone STT mode: transcribe a local audio/video file.
    Outputs transcript text to stdout, all diagnostics to stderr.

    Args:
        file_path: Path to audio/video file

    Returns:
        str: Transcript text, or None on error
    """
    audio_file = Path(file_path).resolve()

    if not audio_file.exists():
        print(f"[-] File not found: {audio_file}", file=sys.stderr)
        return None

    if not MLX_WHISPER_BIN.exists():
        print(f"[-] mlx-whisper not found at: {MLX_WHISPER_BIN}", file=sys.stderr)
        print(
            f"    Install it in {MLX_WHISPER_DIR} with: pip install mlx-whisper",
            file=sys.stderr,
        )
        return None

    success, _, _ = run_command(["ffmpeg", "-version"], log_output=False)
    if not success:
        print(
            "[-] ffmpeg not found. Install with: brew install ffmpeg", file=sys.stderr
        )
        return None

    original_stdout = sys.stdout

    sys.stdout = sys.stderr
    converted_audio = convert_audio_for_whisper(audio_file)
    sys.stdout = original_stdout

    if not converted_audio:
        print("[-] Failed to convert audio for whisper", file=sys.stderr)
        return None

    audio_path = str(converted_audio.resolve())

    cmd = [
        str(MLX_WHISPER_BIN),
        audio_path,
        "--model",
        MLX_WHISPER_MODEL,
        "--output-dir",
        str(audio_file.parent),
        "--output-format",
        "txt",
    ]

    sys.stdout = sys.stderr
    start_time = time.time()
    success, stdout, stderr = run_command(cmd, timeout=300)
    elapsed = time.time() - start_time
    sys.stdout = original_stdout

    if not success:
        print(f"[-] Transcription failed after {elapsed:.1f}s", file=sys.stderr)
        if stderr:
            print(f"    Error: {stderr[-500:]}", file=sys.stderr)
        return None

    whisper_output_file = _find_whisper_output(audio_file)

    if not whisper_output_file:
        print(
            f"[-] Whisper output file not found in {audio_file.parent}", file=sys.stderr
        )
        return None

    try:
        transcript_text = whisper_output_file.read_text(encoding="utf-8").strip()
    except Exception as e:
        print(f"[-] Failed to read whisper output: {e}", file=sys.stderr)
        return None

    if not transcript_text:
        print("[-] Transcription produced empty output", file=sys.stderr)
        return None

    sys.stdout.write(transcript_text)
    sys.stdout.flush()

    for f in [converted_audio, whisper_output_file]:
        try:
            if f.exists():
                f.unlink()
        except OSError:
            pass

    return transcript_text


def copy_transcript(transcript_file):
    """
    Copy transcript to work directory.

    Args:
        transcript_file: Path to transcript file

    Returns:
        Path: Path to copied transcript, or None on error
    """
    logging.info(f"[COPY] Copying transcript to work directory")
    print_step(3, "Copying transcript...")

    dest_file = WORK_DIR / transcript_file.name

    try:
        import shutil

        shutil.copy2(transcript_file, dest_file)

        print_success(f"Copied to: {dest_file}")
        logging.info(f"[COPY] Success: {dest_file.resolve()}")
        return dest_file

    except Exception as e:
        print_error(f"Copy failed: {e}")
        logging.error(f"[COPY] Failed: {e}")
        return None


def generate_summary(transcript_file, video_file, site="other"):
    """
    Generate summary from transcript using OpenCode agent.

    Args:
        transcript_file: Path to transcript file
        video_file: Path to original video file
        site: Site name (for Instagram, adds smart naming + hashtags)

    Returns:
        Path: Path to summary file, or None on error
    """
    logging.info(f"[SUMMARY] Starting AI summary generation for: {video_file.stem}")
    print_step(4, "Generating summary with AI analysis...")
    print_info("Using OpenCode transcript-analyzer agent...")

    # Read transcript to get word count for context
    try:
        with open(transcript_file, "r") as f:
            transcript_text = f.read().strip()
        word_count = len(transcript_text.split())
    except Exception as e:
        print_error(f"Failed to read transcript: {e}")
        return None

    if not transcript_text:
        print_error("Transcript is empty")
        return None

    # Expected summary file location (initial)
    summary_file = WORK_DIR / f"{video_file.stem}-summarize.md"

    # Check if summary already exists (skip regeneration)
    if summary_file.exists():
        file_size = summary_file.stat().st_size
        if file_size > 100:  # At least 100 bytes (not empty)
            print_success(f"Summary already exists: {summary_file.name}")
            print_info(f"Size: {file_size} bytes")
            print_info("Skipping summary generation (use -f flag to force regenerate)")
            logging.info(
                f"[SUMMARY] Skipped (already exists): {summary_file.resolve()}"
            )
            return summary_file

    # Build prompt for OpenCode agent with special handling for Instagram
    if site in ["instagram", "threads", "tiktok"]:
        # For social media with ID-based filenames, ask AI to generate smart title
        prompt = f"""Analyze the video transcript and generate a comprehensive summary.

Video ID: {video_file.stem}
Video source: {site}
Transcript location: {transcript_file}
Output location: {summary_file}
Transcript contains: {word_count} words

IMPORTANT INSTRUCTIONS:
1. Read the transcript file and analyze the content
2. Create a comprehensive summary following your configured structure
3. At the END of the summary, add a section called "## Metadata" with:
   - Suggested filename: Create a SHORT descriptive filename (MAX 3-4 words, lowercase-with-hyphens) based on the main topic
   - Keep it concise and memorable (e.g., "python-tutorial", "ai-basics", "unix-history")
   - Hashtags: Generate 3-5 relevant hashtags for categorization (e.g., #ai #tutorial #productivity)
   - Video ID: {video_file.stem}

Format the metadata section exactly like this:
```
## Metadata
**Suggested Filename:** short-topic-name
**Hashtags:** #tag1 #tag2 #tag3
**Video ID:** {video_file.stem}
```

CRITICAL: Filename MUST be 3-4 words maximum, all lowercase, separated by hyphens only.

Save the summary to the specified output location."""
    else:
        # For YouTube, use regular summary (title is already good)
        prompt = f"""Analyze the video transcript and generate a comprehensive summary.

Video filename: {video_file.stem.replace("_", " ")}
Transcript location: {transcript_file}
Output location: {summary_file}
Transcript contains: {word_count} words

Read the transcript file, perform deep analysis following your configured structure, and save the summary to the specified output location.

At the END of the summary, add relevant hashtags for categorization (3-5 hashtags based on the content, e.g., #python #webdev #tutorial)."""

    # Execute OpenCode agent
    cmd = [
        "opencode",
        "run",
        "--agent",
        "transcript-analyzer",
        prompt,  # Positional argument, not --prompt
    ]

    print_info("Running AI analysis (this may take 30-60 seconds)...")
    logging.debug(f"[SUMMARY] Running OpenCode agent with timeout=600s")
    start_time = time.time()
    success, stdout, stderr = run_command(
        cmd, cwd=WORK_DIR, timeout=600
    )  # 10 min timeout
    elapsed = time.time() - start_time

    if not success:
        print_error("Failed to generate summary with OpenCode agent")
        if stderr:
            print_error(f"Error: {stderr[:500]}")
        logging.error(f"[SUMMARY] Failed after {elapsed:.1f}s")
        logging.error(f"[SUMMARY] Full stderr: {stderr}")
        logging.error(f"[SUMMARY] Full stdout: {stdout}")
        return None

    # Verify summary file was created
    if not summary_file.exists():
        print_error(f"Summary file not created: {summary_file}")
        logging.error(f"[SUMMARY] Summary file not created: {summary_file}")
        return None

    summary_size = summary_file.stat().st_size / 1024  # KB
    print_success(f"Summary created: {summary_file.name}")
    print_info(f"Size: {summary_size:.1f} KB")
    logging.info(
        f"[SUMMARY] Success in {elapsed:.1f}s: {summary_file.resolve()} ({summary_size:.1f} KB)"
    )

    # For Instagram/social media, optionally rename based on AI suggestion
    if site in ["instagram", "threads", "tiktok"]:
        try:
            with open(summary_file, "r") as f:
                summary_content = f.read()

            # Look for suggested filename in metadata section
            import re

            filename_match = re.search(
                r"\*\*Suggested Filename:\*\*\s*([a-z0-9][a-z0-9-]*[a-z0-9])",
                summary_content,
                re.IGNORECASE,
            )

            if filename_match:
                suggested_name = filename_match.group(1).lower().strip()

                # Validate: limit to 4 words (3 hyphens max)
                word_count = suggested_name.count("-") + 1
                if word_count > 4:
                    # Truncate to first 4 words
                    parts = suggested_name.split("-")
                    suggested_name = "-".join(parts[:4])
                    print_warning(f"Truncated long filename to: {suggested_name}")

                # Validate: max 50 characters total
                if len(suggested_name) > 50:
                    suggested_name = suggested_name[:50].rstrip("-")
                    print_warning(f"Truncated filename to 50 chars: {suggested_name}")

                new_summary_file = (
                    WORK_DIR / f"{suggested_name}-{video_file.stem}-summarize.md"
                )

                # Rename if the suggestion is different
                if new_summary_file != summary_file:
                    summary_file.rename(new_summary_file)
                    print_success(f"Renamed summary: {new_summary_file.name}")
                    print_info(f"AI-generated filename based on content")
                    summary_file = new_summary_file
            else:
                print_warning("Could not extract suggested filename from AI response")
                print_info("Keeping original filename")
        except Exception as e:
            print_warning(f"Could not rename based on AI suggestion: {e}")
            print_info("Keeping original filename")

    return summary_file


# ============================================================================
# MAIN FUNCTION
# ============================================================================


def process_single_video(url, audio_only=False, force=False, download_only=False):
    """
    Process a single video URL.

    Args:
        url: Video URL
        audio_only: Download audio only
        force: Force re-transcription even if transcript exists
        download_only: Download only, skip transcription and summary

    Returns:
        bool: Success status
    """
    overall_start = time.time()

    # Step 1: Download
    logging.info(f"Processing URL: {url}")
    video_file, already_existed, site = download_video(url, audio_only=audio_only)
    if not video_file:
        print_error("Failed to download video")
        logging.error(f"Download failed for: {url}")
        return False

    # If download-only mode, stop here
    if download_only:
        overall_elapsed = time.time() - overall_start
        print_header("Download Complete!")
        print_success("Video downloaded successfully (download-only mode)")
        print_info(f"Total time: {overall_elapsed:.1f}s")
        print(f"\n{Colors.BOLD}Output:{Colors.RESET}")
        print(f"  [Video] {video_file}")

        # Log downloaded file
        logging.info(f"Downloaded (audio-only={audio_only}): {video_file.resolve()}")
        logging.info(f"Processing time: {overall_elapsed:.1f}s")

        return True

    # Step 2: Transcribe
    transcript_file = transcribe_video(video_file, force=force)
    if not transcript_file:
        print_error("Failed to transcribe video")
        return False

    # Step 3: Copy transcript
    transcript_copy = copy_transcript(transcript_file)
    if not transcript_copy:
        print_error("Failed to copy transcript")
        return False

    # Step 4: Generate summary (with site info for smart naming)
    summary_file = generate_summary(transcript_copy, video_file, site=site)
    if not summary_file:
        print_error("Failed to generate summary")
        return False

    # Success!
    overall_elapsed = time.time() - overall_start

    print_header("Processing Complete!")
    print_success("All steps completed successfully")
    print_info(f"Total time: {overall_elapsed:.1f}s")

    print(f"\n{Colors.BOLD}Output Files:{Colors.RESET}")
    print(f"  Video:      {video_file}")
    print(f"  Transcript: {transcript_copy}")
    print(f"  Summary:    {summary_file}")

    # Log all processed files with full paths (DEBUG LOG)
    logging.info(f"Processing completed successfully for: {url}")
    logging.info(f"  Video (audio-only={audio_only}): {video_file.resolve()}")
    logging.info(f"  Transcript: {transcript_copy.resolve()}")
    logging.info(f"  Summary: {summary_file.resolve()}")
    logging.info(f"  Total processing time: {overall_elapsed:.1f}s")
    logging.info("-" * 60)

    # Log to PROCESSED FILES LOG (clean file history)
    processed_logger = logging.getLogger("processed")
    processed_logger.info(f"URL: {url}")
    processed_logger.info(f"  Video: {video_file.resolve()}")
    processed_logger.info(f"  Transcript: {transcript_copy.resolve()}")
    processed_logger.info(f"  Summary: {summary_file.resolve()}")
    processed_logger.info(f"  Time: {overall_elapsed:.1f}s")
    processed_logger.info("-" * 80)

    return True


def main():
    """Main execution function."""
    parser = argparse.ArgumentParser(
        description="TVS - Text-Video-Summarizer: Download, transcribe, and summarize videos",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog=f"""
Examples:
  # Single video (recommended)
  python3.13 tvs.py -u https://youtube.com/watch?v=dQw4w9WgXcQ -a -t

  # With custom output directory (e.g., your Obsidian vault)
  python3.13 tvs.py -u https://youtube.com/watch?v=dQw4w9WgXcQ -a -o /path/to/vault

   # Batch processing from file
   python3.13 tvs.py --list urls.txt -a -t

   # Transcribe a local audio file (standalone STT)
   python3.13 tvs.py --stt /path/to/audio.ogg

Notes:
  - Transcription: mlx-whisper (distil-whisper-large-v3)
  - Videos saved to: {VIDEOS_DIR}/
  - Transcripts/summaries saved to: {WORK_DIR}/ (or custom with -o)
  - URL list file format: one URL per line, blank lines and # comments ignored
        """,
    )

    group = parser.add_mutually_exclusive_group(required=False)
    group.add_argument("-u", "--url", help="Single video URL (YouTube, etc.)")
    group.add_argument(
        "-l", "--list", help="Text file containing list of URLs (one per line)"
    )
    group.add_argument(
        "--stt",
        metavar="FILE",
        help="Transcribe a local audio/video file (standalone STT mode, outputs to stdout)",
    )

    parser.add_argument(
        "-a",
        "--audio-only",
        action="store_true",
        help="Download audio only (smaller file size, faster download)",
    )

    parser.add_argument(
        "-t",
        "--terminal",
        action="store_true",
        help="Show live output in terminal (no buffering, real-time updates)",
    )

    parser.add_argument(
        "-f",
        "--force",
        action="store_true",
        help="Force re-transcription even if transcript already exists",
    )

    parser.add_argument(
        "-d",
        "--download-only",
        action="store_true",
        help="Download video only (skip transcription and summary)",
    )

    parser.add_argument(
        "--colors",
        action="store_true",
        help="Show color demo and exit",
    )

    parser.add_argument(
        "-o",
        "--output",
        help="Custom directory for transcripts and summaries (e.g., your Obsidian vault)",
    )

    args = parser.parse_args()

    if args.colors:
        print_color_demo()
        return 0

    if args.stt:
        result = transcribe_file_stt(args.stt)
        return 0 if result else 1

    if not args.url and not args.list and not args.stt:
        parser.error("one of the arguments -u/--url -l/--list --stt is required")

    # Enable unbuffered output if -t flag is used
    if args.terminal:
        sys.stdout.reconfigure(line_buffering=True)
        sys.stderr.reconfigure(line_buffering=True)

    # Set custom work directory if -o flag is provided
    if args.output:
        set_work_dir(args.output)
        print_info(f"Using custom output directory: {WORK_DIR}")

    # Setup logging
    debug_log, processed_log = setup_logging()

    # Print header
    print_header("TVS - Text-Video-Summarizer")
    print_info(f"Started at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    print_info(f"Debug log: {debug_log}")
    print_info(f"Processed files log: {processed_log}")

    # Validate environment
    if not validate_environment():
        print_error("Environment validation failed. Please fix the issues above.")
        return 1

    # Determine processing mode
    if args.url:
        # Single video mode
        print_info("Mode: Single video")
        if args.audio_only:
            print_info("Quality: Audio-only (fast, small file)")
        else:
            print_info("Quality: 480p max (balanced)")

        success = process_single_video(
            args.url,
            audio_only=args.audio_only,
            force=args.force,
            download_only=args.download_only,
        )

        if success:
            print(f"\n{Colors.SUCCESS}{Colors.BOLD}>> Summary is ready!{Colors.RESET}")
            logging.info("Session completed successfully")
            logging.info("=" * 60)
            return 0
        else:
            logging.error("Session failed")
            logging.info("=" * 60)
            return 1

    elif args.list:
        # Batch mode from file
        print_info(f"Mode: Batch processing from file")
        print_info(f"URL list: {args.list}")

        # Read URLs from file
        try:
            with open(args.list, "r") as f:
                lines = f.readlines()
        except FileNotFoundError:
            print_error(f"File not found: {args.list}")
            return 1
        except Exception as e:
            print_error(f"Error reading file: {e}")
            return 1

        # Parse URLs (skip blank lines and comments)
        urls = []
        for line_num, line in enumerate(lines, 1):
            line = line.strip()
            # Skip blank lines and comments
            if not line or line.startswith("#"):
                continue
            urls.append((line_num, line))

        if not urls:
            print_error("No URLs found in file")
            return 1

        print_info(f"Found {len(urls)} URL(s) to process")

        # Process each URL
        total_start = time.time()
        results = {"success": 0, "failed": 0, "skipped": 0}

        for idx, (line_num, url) in enumerate(urls, 1):
            print(f"\n{Colors.BOLD}{'─' * 60}{Colors.ENDC}\n")
            print(f"{Colors.BOLD}{'─' * 60}{Colors.ENDC}\n")

            logging.info(f"Starting batch video {idx}/{len(urls)}: {url}")

            success = process_single_video(
                url,
                audio_only=args.audio_only,
                force=args.force,
                download_only=args.download_only,
            )

            if success:
                results["success"] += 1
            else:
                results["failed"] += 1
                logging.warning(f"Failed to process video {idx}/{len(urls)}: {url}")
                print_warning("Continuing with next video...")

        # Print batch summary
        total_elapsed = time.time() - total_start

        print_header("Batch Processing Complete!")
        print(f"\n{Colors.BOLD}Statistics:{Colors.ENDC}")
        print(f"  ✅ Successful: {Colors.SUCCESS}{results['success']}{Colors.RESET}")
        print(f"  ❌ Failed:     {Colors.ERROR}{results['failed']}{Colors.RESET}")
        print(f"  📊 Total:      {len(urls)}")
        print(f"  ⏱️  Time:       {total_elapsed:.1f}s ({total_elapsed / 60:.1f} min)")
        print(
            f"\n{Colors.SUCCESS}{Colors.BOLD}[+] {results['success']} video(s) processed successfully!{Colors.RESET}"
        )

        # Log batch processing summary
        logging.info("=" * 60)
        logging.info("BATCH PROCESSING SUMMARY")
        logging.info(f"Total videos: {len(urls)}")
        logging.info(f"Successful: {results['success']}")
        logging.info(f"Failed: {results['failed']}")
        logging.info(f"Total time: {total_elapsed:.1f}s ({total_elapsed / 60:.1f} min)")
        logging.info("=" * 60)

        # Return 0 if at least one succeeded
        return 0 if results["success"] > 0 else 1


# ============================================================================
# ENTRY POINT
# ============================================================================

if __name__ == "__main__":
    try:
        sys.exit(main())
    except KeyboardInterrupt:
        print(f"\n\n{Colors.WARNING}⚠️  Interrupted by user{Colors.ENDC}")
        sys.exit(130)
    except Exception as e:
        print_error(f"Unexpected error: {e}")
        import traceback

        traceback.print_exc()
        sys.exit(1)