ai_gui_auto_video_editor/

batch_processor.rs

use anyhow::{Context, Result};
use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
use std::fs;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use tracing::{debug, info, warn};

use crate::analyzer::ProcessedSegment;
use crate::analyzer::VideoAnalyzer;
use crate::config::Config;
use crate::editor::VideoEditor;
use crate::editor::calculate_keep_segments;
use crate::editor::calculate_keep_segments_from_transcript;
use crate::exporter;
use crate::progress::BatchProgress;
use crate::stt_analyzer::{CandleSttAnalyzer, TranscriptSegment, VideoSttAnalyzer};
use crate::utils::{TempFile, find_video_files};

fn atomic_replace(src: &Path, dst: &Path) -> Result<()> {
    #[cfg(target_os = "windows")]
    {
        if dst.exists() {
            std::fs::remove_file(dst).context("failed to remove existing destination")?;
        }
    }
    std::fs::rename(src, dst).context("atomic replace failed")
}

/// RAII guard for cleaning up temporary video files on drop.
/// Tracks intermediate files and removes them when the guard goes out of scope.
struct TempFileGuard {
    temps: Vec<PathBuf>,
    output: PathBuf,
}

impl TempFileGuard {
    fn new(output: PathBuf) -> Self {
        Self {
            temps: Vec::new(),
            output,
        }
    }

    fn track(&mut self, path: PathBuf) {
        if path != self.output && !self.temps.contains(&path) {
            self.temps.push(path);
        }
    }

    fn untrack(&mut self, path: &Path) {
        self.temps.retain(|p| p != path);
    }
}

impl Drop for TempFileGuard {
    fn drop(&mut self) {
        for path in &self.temps {
            if let Err(e) = fs::remove_file(path) {
                debug!(path = ?path, error = %e, "Failed to remove temp file");
            }
        }
    }
}

#[derive(Debug, Clone)]
pub struct ProcessingProgress {
    pub fraction: f32,
    pub stage: String,
}

// Trait for getting video duration
pub trait DurationGetter: Send + Sync {
    fn get_duration(&self, path: &Path) -> Result<f32>;
}

// Concrete implementation using ffprobe
pub struct FfmpegDurationGetter;

impl DurationGetter for FfmpegDurationGetter {
    fn get_duration(&self, path: &Path) -> Result<f32> {
        let output = std::process::Command::new("ffprobe")
            .args([
                "-v",
                "error",
                "-show_entries",
                "format=duration",
                "-of",
                "default=noprint_wrappers=1:nokey=1",
                path.to_str().context("invalid path")?,
            ])
            .output()
            .context("failed to execute ffprobe")?;

        let val_str = String::from_utf8_lossy(&output.stdout).trim().to_string();
        val_str.parse::<f32>().context("failed to parse duration")
    }
}

/// Duration getter that caches results keyed by file metadata.
/// Uses modification time + file size to detect changes.
pub struct CachingDurationGetter {
    inner: FfmpegDurationGetter,
    cache: std::sync::Mutex<std::collections::HashMap<PathBuf, (std::time::SystemTime, u64, f32)>>,
}

impl CachingDurationGetter {
    pub fn new() -> Self {
        Self {
            inner: FfmpegDurationGetter,
            cache: std::sync::Mutex::new(std::collections::HashMap::new()),
        }
    }
}

impl DurationGetter for CachingDurationGetter {
    fn get_duration(&self, path: &Path) -> Result<f32> {
        let metadata = std::fs::metadata(path)
            .with_context(|| format!("failed to read metadata for {:?}", path))?;
        let mtime = metadata
            .modified()
            .unwrap_or(std::time::SystemTime::UNIX_EPOCH);
        let file_size = metadata.len();

        {
            let cache = self.cache.lock().unwrap_or_else(|p| p.into_inner());
            if let Some((cached_mtime, cached_size, cached_dur)) = cache.get(path)
                && *cached_mtime == mtime
                && *cached_size == file_size
            {
                return Ok(*cached_dur);
            }
        }

        let duration = self.inner.get_duration(path)?;

        let mut cache = self.cache.lock().unwrap_or_else(|p| p.into_inner());
        cache.insert(path.to_path_buf(), (mtime, file_size, duration));

        Ok(duration)
    }
}

impl Default for CachingDurationGetter {
    fn default() -> Self {
        Self::new()
    }
}

/// Concatenate intro/outro videos using ffmpeg concat demuxer
/// Uses a list file instead of filter_complex to avoid filter injection risks
fn concatenate_videos(
    intro: Option<&Path>,
    main: &Path,
    outro: Option<&Path>,
    output: &Path,
) -> Result<()> {
    let has_intro = intro.is_some();
    let has_outro = outro.is_some();

    if !has_intro && !has_outro {
        fs::copy(main, output)?;
        return Ok(());
    }

    // Collect video paths in order
    let mut video_paths: Vec<&Path> = Vec::new();
    if let Some(p) = intro {
        video_paths.push(p);
    }
    video_paths.push(main);
    if let Some(p) = outro {
        video_paths.push(p);
    }

    // Build concat demuxer list file
    // Escape single quotes in paths: replace ' with '\''
    let list_content: String = video_paths
        .iter()
        .map(|p| {
            let path_str = p.to_string_lossy();
            let escaped = path_str.replace("'", "'\\''");
            format!("file '{}'\n", escaped)
        })
        .collect();
    let list_file = TempFile::new("agave-concat-list", "txt")?;
    std::fs::write(list_file.path(), list_content)?;

    let status = std::process::Command::new("ffmpeg")
        .args(["-f", "concat", "-safe", "0", "-i"])
        .arg(list_file.path())
        .args(["-c", "copy", "-y"])
        .arg(output)
        .status()
        .context("failed to execute ffmpeg for concat")?;

    if !status.success() {
        anyhow::bail!("ffmpeg concat failed with status: {}", status);
    }

    Ok(())
}

pub fn process_single_file<A, E, D>(
    input_file: PathBuf,
    output_file: PathBuf,
    config: &Config,
    analyzer: &A,
    editor: &E,
    duration_getter: &D,
) -> Result<()>
where
    A: VideoAnalyzer,
    E: VideoEditor,
    D: DurationGetter,
{
    process_single_file_with_intro_outro(
        input_file,
        output_file,
        config,
        analyzer,
        editor,
        duration_getter,
        None,
        None,
    )
}

#[allow(clippy::too_many_arguments)]
pub fn process_single_file_with_intro_outro<A, E, D>(
    input_file: PathBuf,
    output_file: PathBuf,
    config: &Config,
    analyzer: &A,
    editor: &E,
    duration_getter: &D,
    intro: Option<PathBuf>,
    outro: Option<PathBuf>,
) -> Result<()>
where
    A: VideoAnalyzer,
    E: VideoEditor,
    D: DurationGetter,
{
    process_single_file_with_intro_outro_progress(
        input_file,
        output_file,
        config,
        analyzer,
        editor,
        duration_getter,
        intro,
        outro,
        |_| {},
    )
}

#[allow(clippy::too_many_arguments)]
pub fn process_single_file_with_intro_outro_progress<A, E, D, F>(
    input_file: PathBuf,
    output_file: PathBuf,
    config: &Config,
    analyzer: &A,
    editor: &E,
    duration_getter: &D,
    intro: Option<PathBuf>,
    outro: Option<PathBuf>,
    mut progress: F,
) -> Result<()>
where
    A: VideoAnalyzer,
    E: VideoEditor,
    D: DurationGetter,
    F: FnMut(ProcessingProgress),
{
    // Guard ensures temp files are cleaned up even on early return
    let mut guard = TempFileGuard::new(output_file.clone());

    report_progress(&mut progress, 0.02, "Analyzing silence");
    info!(file = ?input_file, "Analyzing video");
    debug!(mode = ?config.silence.mode, "Silence mode");

    let silences = analyzer
        .detect_silence(
            &input_file,
            config.silence.threshold_db,
            config.silence.min_duration,
        )
        .context("Failed to detect silence")?;

    info!(count = silences.len(), "Detected silent segments");

    report_progress(&mut progress, 0.08, "Planning edits");
    let video_duration = duration_getter.get_duration(&input_file)?;
    debug!(duration = video_duration, "Video duration");

    // Merge scene changes with silences if scene detection is enabled
    let silences = if config.silence.scene_detect {
        report_progress(&mut progress, 0.09, "Detecting scene changes");
        match crate::scene_detection::detect_scene_changes(
            &input_file,
            config.silence.scene_threshold,
        ) {
            Ok(scenes) => {
                info!(count = scenes.len(), "Detected scene changes");
                merge_silences_and_scenes(&silences, &scenes, video_duration)
            }
            Err(e) => {
                warn!(error = %e, "Scene detection failed, using silence only");
                silences
            }
        }
    } else {
        silences
    };

    report_progress(&mut progress, 0.1, "Planning edits");

    // Fetch transcript if needed for filler-word removal or audio ducking
    let transcript = if config.filler_words.enabled || config.audio.music_file.is_some() {
        report_progress(&mut progress, 0.1, "Transcribing audio");
        maybe_transcribe(&input_file, config)
    } else {
        None
    };

    let processed_segments = if config.filler_words.enabled {
        match &transcript {
            Some(t) => {
                let filler_words: Vec<&str> = config
                    .filler_words
                    .words
                    .iter()
                    .map(|s| s.as_str())
                    .collect();
                calculate_keep_segments_from_transcript(
                    t,
                    video_duration,
                    &filler_words,
                    config.filler_words.padding,
                )
            }
            None => calculate_keep_segments(
                &silences,
                video_duration,
                config.silence.padding,
                config.silence.mode,
                config.silence.speedup_factor,
                config.silence.min_silence_for_speedup,
            ),
        }
    } else {
        calculate_keep_segments(
            &silences,
            video_duration,
            config.silence.padding,
            config.silence.mode,
            config.silence.speedup_factor,
            config.silence.min_silence_for_speedup,
        )
    };
    debug!(count = processed_segments.len(), "Segments to process");

    let trimmed_file = if config.audio.enhance
        || config.audio.music_file.is_some()
        || intro.is_some()
        || outro.is_some()
    {
        let path = output_file.with_extension("trimmed.mp4");
        guard.track(path.clone());
        path
    } else {
        output_file.clone()
    };

    report_progress(&mut progress, 0.15, "Trimming video");
    editor
        .trim_video_with_progress(
            &input_file,
            &trimmed_file,
            &processed_segments,
            &mut |value| {
                let percent = 0.15 + (value * 0.6);
                report_progress(
                    &mut progress,
                    percent,
                    format!("Trimming video ({:.0}%)", value * 100.0),
                );
            },
        )
        .context("Failed to trim video")?;
    debug!(file = ?trimmed_file, "Trimmed video saved");

    let audio_file = if config.audio.noise_reduction {
        let denoised = output_file.with_extension("denoised.mp4");
        report_progress(&mut progress, 0.74, "Reducing noise");
        info!("Reducing audio noise");
        editor.reduce_noise(&trimmed_file, &denoised)?;
        if trimmed_file != output_file {
            guard.untrack(&trimmed_file);
            let _ = fs::remove_file(&trimmed_file);
        }
        guard.track(denoised.clone());
        denoised
    } else {
        trimmed_file
    };

    let enhanced_file = if config.audio.enhance {
        let enhanced = output_file.with_extension("enhanced.mp4");
        report_progress(&mut progress, 0.78, "Enhancing audio");
        info!("Enhancing audio");
        editor
            .enhance_audio(&audio_file, &enhanced, config.audio.target_lufs)
            .context("Failed to enhance audio")?;

        if audio_file != output_file {
            guard.untrack(&audio_file);
            let _ = fs::remove_file(&audio_file);
        }
        guard.track(enhanced.clone());
        enhanced
    } else {
        audio_file
    };

    let with_music_file = if let Some(ref music_path) = config.audio.music_file {
        let with_music = output_file.with_extension("music.mp4");
        report_progress(&mut progress, 0.84, "Mixing background music");
        info!(music = ?music_path, "Mixing background music");

        editor
            .mix_with_music(
                &enhanced_file,
                music_path,
                &with_music,
                transcript.as_deref().unwrap_or(&[]),
                config.audio.duck_volume,
            )
            .context("Failed to mix music")?;

        if enhanced_file != output_file {
            guard.untrack(&enhanced_file);
            let _ = fs::remove_file(&enhanced_file);
        }
        guard.track(with_music.clone());
        with_music
    } else {
        enhanced_file
    };

    let concat_file = if intro.is_some() || outro.is_some() {
        report_progress(&mut progress, 0.88, "Adding intro/outro");
        info!("Adding intro/outro");
        concatenate_videos(
            intro.as_deref(),
            &with_music_file,
            outro.as_deref(),
            &output_file,
        )?;

        if with_music_file != output_file {
            guard.untrack(&with_music_file);
            let _ = fs::remove_file(&with_music_file);
        }
        guard.track(output_file.clone());
        output_file.clone()
    } else {
        if with_music_file != output_file {
            guard.untrack(&with_music_file);
            fs::rename(&with_music_file, &output_file)?;
        }
        output_file.clone()
    };

    let mut current_file = concat_file;

    if config.video.stabilize {
        let stabilized = output_file.with_extension("stabilized.mp4");
        report_progress(&mut progress, 0.9, "Stabilizing video");
        info!("Stabilizing video");
        editor.stabilize(&current_file, &stabilized)?;
        if current_file != output_file {
            guard.untrack(&current_file);
            let _ = fs::remove_file(&current_file);
        }
        guard.track(stabilized.clone());
        current_file = stabilized;
    }

    if config.video.color_correct {
        let corrected = output_file.with_extension("corrected.mp4");
        report_progress(&mut progress, 0.93, "Color correcting");
        info!("Color correcting");
        editor.color_correct(&current_file, &corrected)?;
        if current_file != output_file {
            guard.untrack(&current_file);
            let _ = fs::remove_file(&current_file);
        }
        guard.track(corrected.clone());
        current_file = corrected;
    }

    if config.video.reframe {
        let reframed = output_file.with_extension("reframed.mp4");
        report_progress(&mut progress, 0.95, "Auto-reframing");
        info!("Auto-reframing to vertical (9:16)");
        editor.reframe(&current_file, &reframed, config.video.target_resolution)?;
        if current_file != output_file {
            guard.untrack(&current_file);
            let _ = fs::remove_file(&current_file);
        }
        guard.track(reframed.clone());
        current_file = reframed;
    }

    if config.video.blur_background {
        let blurred = output_file.with_extension("blurred.mp4");
        report_progress(&mut progress, 0.97, "Blurring background");
        info!("Blurring background");
        editor.blur_background(&current_file, &blurred)?;
        if current_file != output_file {
            guard.untrack(&current_file);
            let _ = fs::remove_file(&current_file);
        }
        guard.track(blurred.clone());
        current_file = blurred;
    }

    // Apply target resolution scaling if configured and not already reframed
    // Scaling must happen BEFORE watermarking to avoid stretching the watermark
    if !config.video.reframe
        && config.video.target_resolution != crate::config::VideoResolution::default()
    {
        let (target_w, target_h) = config.video.target_resolution.dimensions();
        let scaled = output_file.with_extension("scaled.mp4");
        report_progress(&mut progress, 0.96, "Scaling to target resolution");
        info!(resolution = ?config.video.target_resolution, "Scaling to target resolution");
        let status = std::process::Command::new("ffmpeg")
            .arg("-i")
            .arg(&current_file)
            .args(["-vf", &format!("scale={}:{}", target_w, target_h)])
            .args(["-c:a", "copy", "-y"])
            .arg(&scaled)
            .status()
            .context("failed to scale video")?;
        if !status.success() {
            anyhow::bail!("ffmpeg scale failed with status: {}", status);
        }
        if current_file != output_file {
            guard.untrack(&current_file);
            let _ = fs::remove_file(&current_file);
        }
        guard.track(scaled.clone());
        current_file = scaled;
    }

    // Apply watermark if configured (must be LAST video processing step)
    if let Some(ref watermark_path) = config.video.watermark {
        let watermarked = output_file.with_extension("watermarked.mp4");
        report_progress(&mut progress, 0.98, "Adding watermark");
        info!(watermark = ?watermark_path, "Adding watermark");

        let position =
            crate::watermark::WatermarkPosition::parse_name(&config.video.watermark_position)
                .unwrap_or(crate::watermark::WatermarkPosition::BottomRight);
        let scale = config.video.watermark_scale;

        crate::watermark::add_watermark(
            &current_file,
            watermark_path,
            &watermarked,
            position,
            scale,
        )?;

        if current_file != output_file {
            guard.untrack(&current_file);
            let _ = fs::remove_file(&current_file);
        }
        guard.track(watermarked.clone());
        current_file = watermarked;
    }

    // Move final temp file to output if needed
    if current_file != output_file {
        fs::rename(&current_file, &output_file)?;
    }
    guard.untrack(&output_file); // Don't delete the final output

    report_progress(&mut progress, 0.99, "Writing exports");
    export_additional_files(
        &input_file,
        &output_file,
        &processed_segments,
        config,
        transcript.as_deref(),
    )?;

    report_progress(&mut progress, 1.0, "Done");
    info!(file = ?output_file, "Successfully saved video");
    Ok(())
}

/// Transcribe the input file if transcription is needed for processing.
/// Returns `Some(transcript)` on success, `None` on failure or if not needed.
fn maybe_transcribe(input_file: &Path, _config: &Config) -> Option<Vec<TranscriptSegment>> {
    match CandleSttAnalyzer.transcribe(input_file) {
        Ok(t) => {
            info!(segments = t.len(), "Transcription complete");
            Some(t)
        }
        Err(e) => {
            warn!(error = %e, "Transcription failed");
            None
        }
    }
}

/// Merge silence segments with scene-change boundaries.
/// Scene changes are treated as additional cut points - they split existing
/// silence segments or create new boundaries for trimming.
fn merge_silences_and_scenes(
    silences: &[crate::analyzer::Segment],
    scenes: &[f32],
    duration: f32,
) -> Vec<crate::analyzer::Segment> {
    if scenes.is_empty() {
        return silences.to_vec();
    }

    let scene_segments = crate::scene_detection::scenes_to_segments(scenes, duration);

    let mut merged: Vec<crate::analyzer::Segment> = silences
        .iter()
        .map(|silence| {
            let mut start = silence.start;
            let mut end = silence.end;

            for scene in &scene_segments {
                if (scene.start - start).abs() < 0.5 {
                    start = scene.start.min(start);
                }
                if (scene.end - end).abs() < 0.5 {
                    end = scene.end.max(end);
                }
            }

            crate::analyzer::Segment { start, end }
        })
        .collect();

    merged.sort_by(|a, b| a.start.total_cmp(&b.start));

    let mut deduplicated: Vec<crate::analyzer::Segment> = Vec::new();
    for seg in merged {
        if let Some(last) = deduplicated.last_mut()
            && seg.start <= last.end
        {
            last.end = last.end.max(seg.end);
            continue;
        }
        deduplicated.push(seg);
    }

    deduplicated
}

fn report_progress<F>(progress: &mut F, fraction: f32, stage: impl Into<String>)
where
    F: FnMut(ProcessingProgress),
{
    progress(ProcessingProgress {
        fraction: fraction.clamp(0.0, 1.0),
        stage: stage.into(),
    });
}

fn format_batch_summary(total: usize, successful: usize, failed: usize, skipped: usize) -> String {
    let width = total.to_string().len().max(3);
    let s_pct = successful
        .checked_mul(100)
        .and_then(|v| v.checked_div(total))
        .unwrap_or(0);
    let f_pct = failed
        .checked_mul(100)
        .and_then(|v| v.checked_div(total))
        .unwrap_or(0);

    let green = "\x1b[32m";
    let red = "\x1b[31m";
    let yellow = "\x1b[33m";
    let reset = "\x1b[0m";

    format!(
        "\n=== BATCH SUMMARY ===\n\
         Total files:     {:>width$}\n\
         {green}  Successful:{reset}      {:>width$} ({s_pct}%)\n\
         {red}  Failed:{reset}          {:>width$} ({f_pct}%)\n\
         {yellow}  Skipped (done):{reset}  {:>width$}\n\
         =====================\n",
        total,
        successful,
        failed,
        skipped,
        width = width,
        green = green,
        red = red,
        yellow = yellow,
        reset = reset,
        s_pct = s_pct,
        f_pct = f_pct,
    )
}

fn print_batch_summary(total: usize, successful: usize, failed: usize, skipped: usize) {
    print!(
        "{}",
        format_batch_summary(total, successful, failed, skipped)
    );
}

/// Export additional files (SRT, chapters, FCPXML, EDL, clips) based on config
fn export_additional_files(
    input_file: &Path,
    output_file: &Path,
    segments: &[ProcessedSegment],
    config: &Config,
    cached_transcript: Option<&[TranscriptSegment]>,
) -> Result<()> {
    let base_path = output_file.with_extension("");

    // Use cached transcript if available, otherwise transcribe the output file
    // NOTE: Cached transcript timestamps come from the ORIGINAL input file.
    // When video is trimmed (silences removed), output timestamps will differ
    // from input timestamps by small amounts (typically <1s per cut, equal to
    // silence padding). For automator use cases this drift is acceptable.
    // If frame-accurate exports are needed, disable filler_words so exports
    // always transcribe the output file directly.
    let transcript: Option<Vec<TranscriptSegment>> = if config.export.subtitles
        || config.export.chapters
        || config.export.captions
        || config.export.clips
    {
        if let Some(t) = cached_transcript {
            info!(segments = t.len(), "Using cached transcript for exports");
            Some(t.to_vec())
        } else {
            match CandleSttAnalyzer.transcribe(output_file) {
                Ok(t) => {
                    info!(segments = t.len(), "Transcription complete");
                    Some(t)
                }
                Err(e) => {
                    warn!(error = %e, "Transcription failed");
                    None
                }
            }
        }
    } else {
        None
    };

    if config.export.subtitles {
        let srt_path = base_path.with_extension("srt");
        debug!(path = %srt_path.display(), "Exporting SRT subtitles");
        if let Some(ref t) = transcript {
            exporter::export_srt(t, &srt_path)?;
        } else {
            fs::write(&srt_path, "# Transcription failed\n")?;
        }
    }

    if config.export.chapters {
        let chapters_path = {
            let mut p = base_path.as_os_str().to_os_string();
            p.push(".chapters.txt");
            PathBuf::from(p)
        };
        debug!(path = %chapters_path.display(), "Exporting YouTube chapters");
        if let Some(ref t) = transcript {
            exporter::export_youtube_chapters(t, &chapters_path)?;
        } else {
            fs::write(&chapters_path, "00:00 Intro\n")?;
        }
    }

    if config.export.captions {
        let ass_path = base_path.with_extension("ass");
        debug!(path = %ass_path.display(), "Generating styled captions");
        if let Some(ref t) = transcript {
            if let Err(e) = generate_styled_captions(t, &ass_path) {
                warn!(error = %e, "Failed to generate styled captions");
            } else {
                info!("Burning captions into video");
                let captioned_path = output_file.with_extension("captioned.mp4");
                burn_subtitles_into_video(output_file, &ass_path, &captioned_path)?;
                atomic_replace(&captioned_path, output_file)?;
            }
        }
    }

    if config.export.clips
        && let Some(ref t) = transcript
    {
        let clips_output_dir = base_path.parent().unwrap_or_else(|| Path::new("."));
        let clip_pattern = format!(
            "{}_clip",
            base_path.file_stem().unwrap_or_default().to_string_lossy()
        );
        match extract_highlight_clips(
            output_file,
            t,
            config.export.clip_count,
            config.export.clip_min_duration,
            config.export.clip_max_duration,
            clips_output_dir,
            &clip_pattern,
        ) {
            Ok(clip_paths) => {
                info!(count = clip_paths.len(), "Extracted highlight clips");
            }
            Err(e) => {
                warn!(error = %e, "Failed to extract highlight clips");
            }
        }
    }

    if config.export.fcpxml {
        let fcpxml_path = base_path.with_extension("fcpxml");
        debug!(path = %fcpxml_path.display(), "Exporting FCPXML");
        exporter::export_fcpxml(segments, input_file, &fcpxml_path)?;
    }

    if config.export.edl {
        let edl_path = base_path.with_extension("edl");
        debug!(path = %edl_path.display(), "Exporting EDL");
        let fps = crate::ml::FrameExtractor::get_video_fps(output_file).unwrap_or_else(|_| {
            warn!("Failed to detect FPS for EDL export, defaulting to 25.0");
            25.0
        });
        exporter::export_edl(segments, input_file, &edl_path, fps)?;
    }

    // Generate thumbnail
    if config.export.thumbnail {
        let thumb_path = base_path.with_extension("jpg");
        debug!(path = %thumb_path.display(), "Generating thumbnail");
        if let Err(e) = crate::thumbnail::generate_thumbnail(
            output_file,
            &thumb_path,
            config.export.thumbnail_width,
            config.export.thumbnail_height,
        ) {
            warn!(error = %e, "Failed to generate thumbnail");
        }
    }

    // Multi-format output
    if config.export.multi_format && !config.export.extra_resolutions.is_empty() {
        debug!("Generating multi-format outputs");
        for resolution in &config.export.extra_resolutions {
            let (w, h) = resolution.dimensions();
            let ext = output_file
                .extension()
                .and_then(|e| e.to_str())
                .unwrap_or("mp4");
            let multi_path = {
                let mut p = base_path.as_os_str().to_os_string();
                p.push(format!("_{}p.{}", h, ext));
                PathBuf::from(p)
            };
            debug!(path = %multi_path.display(), resolution = ?resolution, "Generating alternate resolution");

            let status = std::process::Command::new("ffmpeg")
                .arg("-i")
                .arg(output_file)
                .args(["-vf", &format!("scale={}:{}", w, h)])
                .args(["-c:a", "copy", "-y"])
                .arg(&multi_path)
                .status()
                .context("failed to execute ffmpeg for multi-format")?;

            if !status.success() {
                warn!(path = %multi_path.display(), "Multi-format ffmpeg failed");
            }
        }
    }

    // Generate quick preview
    if config.export.preview {
        let preview_path = crate::preview::preview_path(output_file);
        debug!(path = %preview_path.display(), "Generating preview");
        if let Err(e) = crate::preview::generate_preview(
            output_file,
            &preview_path,
            config.export.preview_duration,
            480,
        ) {
            warn!(error = %e, "Failed to generate preview");
        }
    }

    Ok(())
}

/// Generate styled ASS subtitle file from transcript
fn generate_styled_captions(transcript: &[TranscriptSegment], output_path: &Path) -> Result<()> {
    let mut ass = String::new();
    ass.push_str("[Script Info]\n");
    ass.push_str("Title: Generated Captions\n");
    ass.push_str("ScriptType: v4.00+\n");
    ass.push_str("Collisions: Normal\n");
    ass.push_str("PlayDepth: 0\n\n");

    ass.push_str("[V4+ Styles]\n");
    ass.push_str("Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\n");
    ass.push_str("Style: Default,Arial,48,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,2,2,2,10,10,30,1\n\n");

    ass.push_str("[Events]\n");
    ass.push_str(
        "Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n",
    );

    for seg in transcript {
        let text = seg.text.trim();
        if text.is_empty() || text == "[No speech detected]" {
            continue;
        }
        let start = format_ass_time(seg.start);
        let end = format_ass_time(seg.end);
        // Escape text for ASS format
        // In ASS, \N is a forced newline. Literal backslashes must be escaped as \\.
        // Order matters: escape backslashes first, then newlines.
        let escaped = text
            .replace('\\', "\\\\")
            .replace('\n', "\\N")
            .replace('\r', "");
        ass.push_str(&format!(
            "Dialogue: 0,{},{},Default,,0,0,0,,{}\n",
            start, end, escaped
        ));
    }

    fs::write(output_path, ass)?;
    Ok(())
}

fn format_ass_time(seconds: f32) -> String {
    let seconds = seconds.max(0.0);
    let hours = (seconds / 3600.0) as u32;
    let minutes = ((seconds % 3600.0) / 60.0) as u32;
    let secs = (seconds % 60.0) as u32;
    let centisecs = ((seconds % 1.0) * 100.0) as u32;
    format!("{}:{:02}:{:02}.{:02}", hours, minutes, secs, centisecs)
}

/// Burn subtitle file into video using FFmpeg
fn burn_subtitles_into_video(
    video_path: &Path,
    subtitle_path: &Path,
    output_path: &Path,
) -> Result<()> {
    let escaped_subtitle_path = crate::utils::escape_ffmpeg_filter_path(subtitle_path);
    let status = std::process::Command::new("ffmpeg")
        .arg("-i")
        .arg(video_path)
        .arg("-vf")
        .arg(format!("subtitles='{}'", escaped_subtitle_path))
        .args(["-c:a", "copy", "-y"])
        .arg(output_path)
        .status()
        .context("failed to burn subtitles")?;

    if !status.success() {
        anyhow::bail!("ffmpeg subtitle burn failed with status: {}", status);
    }

    if !output_path.exists() {
        anyhow::bail!("ffmpeg subtitle burn did not produce output file");
    }
    Ok(())
}

/// Extract highlight clips based on audio energy peaks in transcript
fn extract_highlight_clips(
    video_path: &Path,
    transcript: &[TranscriptSegment],
    clip_count: u32,
    min_duration: f32,
    max_duration: f32,
    output_dir: &Path,
    clip_pattern: &str,
) -> Result<Vec<PathBuf>> {
    // Analyze audio energy per transcript segment using ffprobe
    let mut segment_energy: Vec<(f32, f32, f32)> = Vec::new(); // (start, end, energy)

    for seg in transcript {
        let text = seg.text.trim();
        if text.is_empty() || text == "[No speech detected]" {
            continue;
        }

        // Estimate energy from segment duration and word count (proxy for speech energy)
        // Longer segments with more words = more content = higher energy
        let duration = seg.end - seg.start;
        let word_count = text.split_whitespace().count() as f32;
        let energy = word_count / duration.max(1.0); // words per second

        segment_energy.push((seg.start, seg.end, energy));
    }

    if segment_energy.is_empty() {
        return Ok(vec![]);
    }

    // Find peaks: sort by energy and take top N segments
    segment_energy.sort_by(|a, b| b.2.total_cmp(&a.2));

    // Get video duration to clamp clips properly
    let video_duration = crate::ml::FrameExtractor::get_video_duration(video_path)
        .unwrap_or_else(|_| {
            transcript.last().map(|s| s.end).unwrap_or_else(|| {
                warn!(video = %video_path.display(), "Could not determine video duration for clip extraction; using 60.0 as fallback");
                60.0
            })
        });

    let mut clip_times: Vec<(f32, f32)> = Vec::new();
    for &(start, end, _) in segment_energy.iter().take(clip_count as usize) {
        // Expand segment to reasonable clip duration
        let clip_start = (start - 2.0).max(0.0);
        let clip_end = (end + 2.0).min(video_duration);
        let clip_duration = clip_end - clip_start;

        if clip_duration >= min_duration && clip_duration <= max_duration {
            clip_times.push((clip_start, clip_end));
        }
    }

    // Extract clips using FFmpeg
    let mut clip_paths = Vec::new();
    for (i, (clip_start, clip_end)) in clip_times.iter().enumerate() {
        let clip_path = output_dir.join(format!("{}_{}.mp4", clip_pattern, i + 1));

        let duration = clip_end - clip_start;
        // Fast keyframe-seeking with stream copy. Cuts may shift to the nearest keyframe
        // (acceptable for highlight clips). For frame-accurate cuts re-encode instead.
        let status = std::process::Command::new("ffmpeg")
            .args([
                "-ss",
                &format!("{}", clip_start),
                "-i",
                video_path.to_str().context("invalid path")?,
                "-t",
                &format!("{}", duration),
                "-c",
                "copy",
                "-avoid_negative_ts",
                "make_zero",
                "-y",
                clip_path.to_str().context("invalid output path")?,
            ])
            .status()
            .context("failed to extract clip")?;

        if status.success() && clip_path.exists() {
            clip_paths.push(clip_path);
        }
    }

    Ok(clip_paths)
}

pub fn process_batch_dir<A, E, D>(
    input_dir: PathBuf,
    output_dir: PathBuf,
    config: &Config,
    analyzer: &A,
    editor: &E,
    duration_getter: &D,
    no_progress: bool,
) -> Result<()>
where
    A: VideoAnalyzer,
    E: VideoEditor,
    D: DurationGetter,
{
    info!(dir = ?input_dir, "Processing directory");
    debug!(output = ?output_dir, mode = ?config.silence.mode, "Batch config");

    fs::create_dir_all(&output_dir).context(format!(
        "Failed to create output directory {:?}",
        output_dir
    ))?;

    let video_files = find_video_files(&input_dir)?;

    if video_files.is_empty() {
        warn!(dir = ?input_dir, "No supported video files found");
        return Ok(());
    }

    // Load or initialize progress tracking
    let progress_path = BatchProgress::default_path(&input_dir);
    let mut progress = BatchProgress::from_file(&progress_path).unwrap_or_default();
    progress.total = video_files.len();

    let total_files = video_files.len();
    let mut successful_files = 0;
    let mut failed_files = 0;
    let mut skipped_files = 0;

    let pb = if no_progress {
        None
    } else {
        let bar = ProgressBar::new(total_files as u64);
        let template = "{spinner:.green} [{elapsed_precise}] [{bar:40.cyan/blue}] {pos}/{len} [{eta_precise}] {msg}";
        bar.set_style(
            ProgressStyle::default_bar()
                .template(template)
                .unwrap_or_else(|_| ProgressStyle::default_bar())
                .progress_chars("#>-"),
        );
        bar.enable_steady_tick(std::time::Duration::from_millis(250));
        Some(bar)
    };

    let preset_rules = crate::preset_rules::default_preset_rules();

    for input_file in &video_files {
        if progress.is_completed(input_file) {
            info!(file = ?input_file, "Skipping already processed file");
            skipped_files += 1;
            if let Some(ref b) = pb {
                b.inc(1);
            }
            continue;
        }

        let file_name = input_file
            .file_name()
            .context(format!("Could not get file name for {:?}", input_file))?;
        let output_file = output_dir.join(file_name);

        if let Some(ref b) = pb {
            b.set_message(format!("{}", input_file.display()));
        }

        // Apply per-file preset based on filename
        let file_preset = crate::preset_rules::preset_for_file(
            input_file,
            &preset_rules,
            crate::config::Preset::Youtube, // Default when no rule matches
        );
        let file_config = if file_preset != crate::config::Preset::Youtube {
            info!(preset = ?file_preset, file = ?file_name, "Applying filename-based preset");
            let mut c = file_preset.to_config();
            // Merge with base config to preserve paths, exports, etc.
            c = c.merge(config.clone());
            c
        } else {
            config.clone()
        };

        match process_single_file(
            input_file.clone(),
            output_file.clone(),
            &file_config,
            analyzer,
            editor,
            duration_getter,
        ) {
            Ok(_) => {
                info!(file = ?input_file, "Successfully processed");
                successful_files += 1;
                progress.mark_completed(input_file);
            }
            Err(e) => {
                warn!(file = ?input_file, error = %e, "Failed to process");
                failed_files += 1;
                progress.mark_failed(input_file);
            }
        }

        if let Err(e) = progress.to_file(&progress_path) {
            warn!("Failed to save progress file: {}", e);
        }
        if let Some(ref b) = pb {
            b.inc(1);
        }
    }

    if let Some(b) = pb {
        b.finish_with_message("Done");
    }

    print_batch_summary(total_files, successful_files, failed_files, skipped_files);

    info!(
        total = total_files,
        successful = successful_files,
        failed = failed_files,
        skipped = skipped_files,
        "Batch processing complete"
    );

    Ok(())
}

/// Process a directory of videos in parallel using multiple worker threads.
/// Each worker gets its own analyzer/editor instances since they are stateless.
#[allow(clippy::too_many_arguments)]
pub fn process_batch_dir_parallel<A, E, D>(
    input_dir: PathBuf,
    output_dir: PathBuf,
    config: &Config,
    worker_count: usize,
    _analyzer: &A,
    _editor: &E,
    _duration_getter: &D,
    no_progress: bool,
) -> Result<()>
where
    A: VideoAnalyzer + Send + Sync,
    E: VideoEditor + Send + Sync,
    D: DurationGetter + Send + Sync,
{
    let worker_count = worker_count.max(1);
    info!(dir = ?input_dir, workers = worker_count, "Processing directory in parallel");

    fs::create_dir_all(&output_dir).context(format!(
        "Failed to create output directory {:?}",
        output_dir
    ))?;

    let mut video_files = find_video_files(&input_dir)?;

    if video_files.is_empty() {
        warn!(dir = ?input_dir, "No supported video files found");
        return Ok(());
    }

    // Load progress and filter out completed files
    let progress_path = BatchProgress::default_path(&input_dir);
    let mut progress = BatchProgress::from_file(&progress_path).unwrap_or_default();
    video_files.retain(|f| !progress.is_completed(f));

    if video_files.is_empty() {
        info!("All files already processed");
        return Ok(());
    }

    progress.total = video_files.len();

    let total_files = video_files.len();
    let successful_files = Arc::new(AtomicUsize::new(0));
    let failed_files = Arc::new(AtomicUsize::new(0));
    let config = Arc::new(config.clone());
    let output_dir = Arc::new(output_dir);
    let progress = Arc::new(std::sync::Mutex::new(progress));
    let progress_path = Arc::new(progress_path);

    let pb = if no_progress {
        None
    } else {
        let mp = MultiProgress::new();
        let bar = mp.add(ProgressBar::new(total_files as u64));
        let template = "{spinner:.green} [{elapsed_precise}] [{bar:40.cyan/blue}] {pos}/{len} [{eta_precise}] {msg}";
        bar.set_style(
            ProgressStyle::default_bar()
                .template(template)
                .unwrap_or_else(|_| ProgressStyle::default_bar())
                .progress_chars("#>-"),
        );
        bar.set_message("Parallel processing...");
        bar.enable_steady_tick(std::time::Duration::from_millis(250));
        Some(Arc::new(bar))
    };

    // Split files into chunks for each worker
    let chunks: Vec<Vec<PathBuf>> = video_files
        .chunks(total_files.div_ceil(worker_count))
        .map(|c| c.to_vec())
        .collect();

    std::thread::scope(|s| {
        for chunk in chunks {
            let config = Arc::clone(&config);
            let output_dir = Arc::clone(&output_dir);
            let successful = Arc::clone(&successful_files);
            let failed = Arc::clone(&failed_files);
            let progress = Arc::clone(&progress);
            let progress_path = Arc::clone(&progress_path);
            let pb = pb.clone();

            s.spawn(move || {
                for input_file in chunk {
                    let file_name = match input_file.file_name() {
                        Some(name) => name.to_os_string(),
                        None => continue,
                    };
                    let output_file = output_dir.join(&file_name);

                    // Create fresh instances per worker (they're stateless)
                    let analyzer = crate::analyzer::FfmpegAnalyzer;
                    let editor = crate::editor::FfmpegEditor::new(config.video.hw_accel);
                    let duration_getter = FfmpegDurationGetter;

                    let result = process_single_file(
                        input_file.clone(),
                        output_file,
                        &config,
                        &analyzer,
                        &editor,
                        &duration_getter,
                    );

                    match result {
                        Ok(_) => {
                            info!(file = ?input_file, "Successfully processed");
                            successful.fetch_add(1, Ordering::SeqCst);
                            let mut p = progress.lock().unwrap_or_else(|p| p.into_inner());
                            p.mark_completed(&input_file);
                            if let Err(e) = p.to_file(&progress_path) {
                                warn!(error = %e, "Failed to save progress file");
                            }
                        }
                        Err(e) => {
                            warn!(file = ?input_file, error = %e, "Failed to process");
                            failed.fetch_add(1, Ordering::SeqCst);
                            let mut p = progress.lock().unwrap_or_else(|p| p.into_inner());
                            p.mark_failed(&input_file);
                            if let Err(e) = p.to_file(&progress_path) {
                                warn!(error = %e, "Failed to save progress file");
                            }
                        }
                    }
                    if let Some(ref b) = pb {
                        b.inc(1);
                    }
                }
            });
        }
    });

    if let Some(b) = pb {
        b.finish_with_message("Done");
    }

    let successful = successful_files.load(Ordering::SeqCst);
    let failed = failed_files.load(Ordering::SeqCst);
    let skipped = 0usize;

    print_batch_summary(total_files, successful, failed, skipped);

    info!(
        total = total_files,
        successful, failed, "Parallel batch processing complete"
    );

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::analyzer::Segment;
    use tempfile::tempdir;

    #[test]
    fn test_format_ass_time() {
        assert_eq!(format_ass_time(0.0), "0:00:00.00");
        assert_eq!(format_ass_time(5.0), "0:00:05.00");
        assert_eq!(format_ass_time(65.5), "0:01:05.50");
        assert_eq!(format_ass_time(3661.25), "1:01:01.25");
        assert_eq!(format_ass_time(359999.99), "100:00:00.00");
        assert_eq!(format_ass_time(0.001), "0:00:00.00");
        assert_eq!(format_ass_time(-5.0), "0:00:00.00");
        assert_eq!(format_ass_time(-0.001), "0:00:00.00");
    }

    struct MockFfmpegAnalyzer;
    impl crate::analyzer::VideoAnalyzer for MockFfmpegAnalyzer {
        fn detect_silence(
            &self,
            _path: &Path,
            _threshold_db: f32,
            _duration_s: f32,
        ) -> Result<Vec<crate::analyzer::Segment>> {
            Ok(vec![])
        }
    }

    struct MockFfmpegEditor;
    impl VideoEditor for MockFfmpegEditor {
        fn reframe(
            &self,
            _input: &Path,
            _output: &Path,
            _target_resolution: crate::config::VideoResolution,
        ) -> Result<()> {
            Ok(())
        }

        fn blur_background(&self, _input: &Path, _output: &Path) -> Result<()> {
            Ok(())
        }

        fn trim_video(
            &self,
            _input: &Path,
            output: &Path,
            _segments: &[crate::analyzer::ProcessedSegment],
        ) -> Result<()> {
            // Simulate successful trimming by creating an empty output file
            fs::File::create(output)?;
            Ok(())
        }

        fn mix_with_music(
            &self,
            _input: &Path,
            _music: &Path,
            _output: &Path,
            _transcript: &[crate::stt_analyzer::TranscriptSegment],
            _duck_volume: f32,
        ) -> Result<()> {
            Ok(())
        }

        fn enhance_audio(&self, _input: &Path, _output: &Path, _target_lufs: f32) -> Result<()> {
            Ok(())
        }

        fn reduce_noise(&self, _input: &Path, _output: &Path) -> Result<()> {
            Ok(())
        }

        fn stabilize(&self, _input: &Path, _output: &Path) -> Result<()> {
            Ok(())
        }

        fn color_correct(&self, _input: &Path, _output: &Path) -> Result<()> {
            Ok(())
        }
    }

    // Mock DurationGetter for testing purposes
    struct MockDurationGetter;
    impl DurationGetter for MockDurationGetter {
        fn get_duration(&self, _path: &Path) -> Result<f32> {
            Ok(60.0) // Return a dummy duration
        }
    }

    #[test]
    fn test_batch_processing_integration() -> Result<()> {
        let input_dir = tempdir()?;
        let output_dir = tempdir()?;

        // Create dummy video files
        fs::File::create(input_dir.path().join("video1.mp4"))?;
        fs::File::create(input_dir.path().join("video2.mov"))?;
        fs::File::create(input_dir.path().join("document.txt"))?; // Should be ignored

        // Use mock implementations
        let mock_analyzer = MockFfmpegAnalyzer;
        let mock_editor = MockFfmpegEditor;
        let mock_duration_getter = MockDurationGetter;

        // Use config with audio enhancement disabled (mock doesn't create files)
        let mut config = Config::default();
        config.audio.enhance = false;

        let result = process_batch_dir(
            input_dir.path().to_path_buf(),
            output_dir.path().to_path_buf(),
            &config,
            &mock_analyzer,
            &mock_editor,
            &mock_duration_getter,
            true,
        );

        assert!(result.is_ok());

        // Check if output files were created
        let output_files: Vec<_> = fs::read_dir(output_dir.path())?
            .filter_map(|e| e.ok())
            .map(|e| e.path())
            .collect();

        assert_eq!(output_files.len(), 2);
        assert!(output_files.iter().any(|p| p.ends_with("video1.mp4")));
        assert!(output_files.iter().any(|p| p.ends_with("video2.mov")));

        Ok(())
    }

    #[test]
    fn test_batch_processing_empty_dir() -> Result<()> {
        let input_dir = tempdir()?;
        let output_dir = tempdir()?;

        let mock_analyzer = MockFfmpegAnalyzer;
        let mock_editor = MockFfmpegEditor;
        let mock_duration_getter = MockDurationGetter;

        let config = Config::default();

        let result = process_batch_dir(
            input_dir.path().to_path_buf(),
            output_dir.path().to_path_buf(),
            &config,
            &mock_analyzer,
            &mock_editor,
            &mock_duration_getter,
            true,
        );

        assert!(result.is_ok());
        let output_files: Vec<_> = fs::read_dir(output_dir.path())?
            .filter_map(|e| e.ok())
            .collect();
        assert_eq!(output_files.len(), 0);
        Ok(())
    }

    #[test]
    fn test_batch_processing_nonexistent_input_dir() -> Result<()> {
        let output_dir = tempdir()?;

        let mock_analyzer = MockFfmpegAnalyzer;
        let mock_editor = MockFfmpegEditor;
        let mock_duration_getter = MockDurationGetter;

        let config = Config::default();

        // find_video_files returns Ok([]) for nonexistent dirs (WalkDir yields error, filtered to empty)
        // So this should succeed with no files processed
        let result = process_batch_dir(
            PathBuf::from("/nonexistent/path/12345"),
            output_dir.path().to_path_buf(),
            &config,
            &mock_analyzer,
            &mock_editor,
            &mock_duration_getter,
            true,
        );

        assert!(result.is_ok());
        Ok(())
    }

    #[test]
    fn test_find_video_files_empty_dir() {
        let dir = tempdir().unwrap();
        let files = find_video_files(dir.path()).unwrap();
        assert!(files.is_empty());
    }

    #[test]
    fn test_find_video_files_ignores_non_video() {
        let dir = tempdir().unwrap();
        fs::File::create(dir.path().join("video.mp4")).unwrap();
        fs::File::create(dir.path().join("document.txt")).unwrap();
        fs::File::create(dir.path().join("image.jpg")).unwrap();

        let files = find_video_files(dir.path()).unwrap();
        assert_eq!(files.len(), 1);
        assert!(files[0].to_string_lossy().contains("video.mp4"));
    }

    #[test]
    fn test_find_video_files_nested_dirs() {
        let dir = tempdir().unwrap();
        fs::File::create(dir.path().join("video1.mp4")).unwrap();
        fs::create_dir(dir.path().join("subdir")).unwrap();
        fs::File::create(dir.path().join("subdir/video2.mov")).unwrap();

        let files = find_video_files(dir.path()).unwrap();
        assert_eq!(files.len(), 2);
    }

    #[test]
    fn test_find_video_files_case_insensitive() {
        let dir = tempdir().unwrap();
        fs::File::create(dir.path().join("video1.MP4")).unwrap();
        fs::File::create(dir.path().join("video2.mOv")).unwrap();
        fs::File::create(dir.path().join("video3.MKV")).unwrap();

        let files = find_video_files(dir.path()).unwrap();
        assert_eq!(files.len(), 3);
    }

    struct MockFfmpegAnalyzerFails;
    impl crate::analyzer::VideoAnalyzer for MockFfmpegAnalyzerFails {
        fn detect_silence(
            &self,
            _path: &Path,
            _threshold_db: f32,
            _duration_s: f32,
        ) -> Result<Vec<crate::analyzer::Segment>> {
            Err(anyhow::anyhow!("Simulated silence detection failure"))
        }
    }

    #[allow(dead_code)]
    struct MockFfmpegEditorFails;
    impl VideoEditor for MockFfmpegEditorFails {
        fn reframe(
            &self,
            _input: &Path,
            _output: &Path,
            _target_resolution: crate::config::VideoResolution,
        ) -> Result<()> {
            Ok(())
        }
        fn blur_background(&self, _input: &Path, _output: &Path) -> Result<()> {
            Ok(())
        }
        fn trim_video(
            &self,
            _input: &Path,
            output: &Path,
            _segments: &[crate::analyzer::ProcessedSegment],
        ) -> Result<()> {
            fs::File::create(output)?;
            Err(anyhow::anyhow!("Simulated trim failure"))
        }
        fn mix_with_music(
            &self,
            _input: &Path,
            _music: &Path,
            _output: &Path,
            _transcript: &[crate::stt_analyzer::TranscriptSegment],
            _duck_volume: f32,
        ) -> Result<()> {
            Ok(())
        }
        fn enhance_audio(&self, _input: &Path, _output: &Path, _target_lufs: f32) -> Result<()> {
            Ok(())
        }
        fn reduce_noise(&self, _input: &Path, _output: &Path) -> Result<()> {
            Ok(())
        }
        fn stabilize(&self, _input: &Path, _output: &Path) -> Result<()> {
            Ok(())
        }
        fn color_correct(&self, _input: &Path, _output: &Path) -> Result<()> {
            Ok(())
        }
    }

    #[test]
    fn test_batch_processing_with_mock_failure() -> Result<()> {
        let input_dir = tempdir()?;
        let output_dir = tempdir()?;

        fs::File::create(input_dir.path().join("video1.mp4")).unwrap();

        let mock_analyzer = MockFfmpegAnalyzerFails;
        let mock_editor = MockFfmpegEditor;
        let mock_duration_getter = MockDurationGetter;

        let mut config = Config::default();
        config.audio.enhance = false;

        let result = process_batch_dir(
            input_dir.path().to_path_buf(),
            output_dir.path().to_path_buf(),
            &config,
            &mock_analyzer,
            &mock_editor,
            &mock_duration_getter,
            true,
        );

        // Should complete even with failures (logs errors but doesn't panic)
        assert!(result.is_ok());
        Ok(())
    }

    #[test]
    fn test_batch_processing_multiple_video_types() -> Result<()> {
        let input_dir = tempdir()?;
        let output_dir = tempdir()?;

        let video_types = [
            "video1.mp4",
            "video2.mov",
            "video3.avi",
            "video4.mkv",
            "video5.webm",
        ];
        for name in &video_types {
            fs::File::create(input_dir.path().join(name))?;
        }
        fs::File::create(input_dir.path().join("document.txt"))?;

        let mock_analyzer = MockFfmpegAnalyzer;
        let mock_editor = MockFfmpegEditor;
        let mock_duration_getter = MockDurationGetter;

        let config = Config::default();

        let result = process_batch_dir(
            input_dir.path().to_path_buf(),
            output_dir.path().to_path_buf(),
            &config,
            &mock_analyzer,
            &mock_editor,
            &mock_duration_getter,
            true,
        );

        assert!(result.is_ok());
        // Note: with default config (enhance=true), output goes to .trimmed.mp4 intermediate
        // which then gets renamed to final output
        let output_files: Vec<_> = fs::read_dir(output_dir.path())?
            .filter_map(|e| e.ok())
            .map(|e| e.path())
            .collect();
        // With enhance=true, intermediate files are created but may be cleaned up
        // The final output should exist after rename
        assert!(!output_files.is_empty() || output_dir.path().exists());
        Ok(())
    }

    #[test]
    fn test_batch_processing_creates_output_dir() -> Result<()> {
        let input_dir = tempdir()?;
        let output_dir = tempdir()?;

        fs::File::create(input_dir.path().join("video.mp4"))?;

        let mock_analyzer = MockFfmpegAnalyzer;
        let mock_editor = MockFfmpegEditor;
        let mock_duration_getter = MockDurationGetter;

        let config = Config::default();

        // Output dir exists but is empty
        assert!(output_dir.path().exists());

        let result = process_batch_dir(
            input_dir.path().to_path_buf(),
            output_dir.path().join("nested"),
            &config,
            &mock_analyzer,
            &mock_editor,
            &mock_duration_getter,
            true,
        );

        assert!(result.is_ok());
        assert!(output_dir.path().join("nested").exists());
        Ok(())
    }

    #[test]
    fn test_batch_processing_with_disabled_features() -> Result<()> {
        let input_dir = tempdir()?;
        let output_dir = tempdir()?;

        fs::File::create(input_dir.path().join("video.mp4"))?;

        let mock_analyzer = MockFfmpegAnalyzer;
        let mock_editor = MockFfmpegEditor;
        let mock_duration_getter = MockDurationGetter;

        let mut config = Config::default();
        config.audio.enhance = false;
        config.audio.noise_reduction = false;
        config.video.stabilize = false;
        config.video.color_correct = false;
        config.video.reframe = false;
        config.video.blur_background = false;
        config.export.subtitles = false;
        config.export.chapters = false;

        let result = process_batch_dir(
            input_dir.path().to_path_buf(),
            output_dir.path().to_path_buf(),
            &config,
            &mock_analyzer,
            &mock_editor,
            &mock_duration_getter,
            true,
        );

        // With all features disabled, trim is still called which creates the output
        assert!(result.is_ok());
        // The output file should be created (trim_video creates it)
        assert!(output_dir.path().join("video.mp4").exists() || output_dir.path().exists());
        Ok(())
    }

    #[test]
    fn test_batch_processing_progress_persists_across_runs() -> Result<()> {
        let input_dir = tempdir()?;
        let output_dir = tempdir()?;

        fs::File::create(input_dir.path().join("video1.mp4"))?;
        fs::File::create(input_dir.path().join("video2.mp4"))?;

        let mock_analyzer = MockFfmpegAnalyzer;
        let mock_editor = MockFfmpegEditor;
        let mock_duration_getter = MockDurationGetter;

        let mut config = Config::default();
        config.audio.enhance = false;

        // First run
        let result1 = process_batch_dir(
            input_dir.path().to_path_buf(),
            output_dir.path().to_path_buf(),
            &config,
            &mock_analyzer,
            &mock_editor,
            &mock_duration_getter,
            true,
        );
        assert!(result1.is_ok());

        // Second run should skip already completed files
        let result2 = process_batch_dir(
            input_dir.path().to_path_buf(),
            output_dir.path().to_path_buf(),
            &config,
            &mock_analyzer,
            &mock_editor,
            &mock_duration_getter,
            true,
        );
        assert!(result2.is_ok());

        // Both files should exist (one from each run)
        let output_files: Vec<_> = fs::read_dir(output_dir.path())?
            .filter_map(|e| e.ok())
            .map(|e| e.path())
            .collect();
        assert_eq!(output_files.len(), 2);
        Ok(())
    }

    // Tests for merge_silences_and_scenes

    #[test]
    fn test_merge_silences_and_scenes_empty_scenes() {
        let silences = vec![
            Segment {
                start: 1.0,
                end: 3.0,
            },
            Segment {
                start: 5.0,
                end: 7.0,
            },
        ];
        let scenes: Vec<f32> = vec![];
        let merged = merge_silences_and_scenes(&silences, &scenes, 10.0);
        assert_eq!(merged.len(), 2);
        assert_eq!(
            merged[0],
            Segment {
                start: 1.0,
                end: 3.0
            }
        );
        assert_eq!(
            merged[1],
            Segment {
                start: 5.0,
                end: 7.0
            }
        );
    }

    #[test]
    fn test_merge_silences_and_scenes_empty_silences() {
        let silences: Vec<Segment> = vec![];
        let scenes = vec![2.0, 5.0];
        let merged = merge_silences_and_scenes(&silences, &scenes, 10.0);
        assert_eq!(merged.len(), 0);
    }

    #[test]
    fn test_merge_silences_and_scenes_overlapping_silences() {
        // Two silences that overlap - without scenes they remain separate
        // (deduplication only happens when scenes cause overlaps)
        let silences = vec![
            Segment {
                start: 1.0,
                end: 3.0,
            },
            Segment {
                start: 2.5,
                end: 5.0,
            },
        ];
        let scenes: Vec<f32> = vec![];
        let merged = merge_silences_and_scenes(&silences, &scenes, 10.0);
        assert_eq!(merged.len(), 2);
    }

    #[test]
    fn test_merge_silences_and_scenes_adjacent_silences() {
        // Adjacent silences without scenes remain separate
        let silences = vec![
            Segment {
                start: 1.0,
                end: 3.0,
            },
            Segment {
                start: 3.0,
                end: 5.0,
            },
        ];
        let scenes: Vec<f32> = vec![];
        let merged = merge_silences_and_scenes(&silences, &scenes, 10.0);
        assert_eq!(merged.len(), 2);
    }

    #[test]
    fn test_merge_silences_and_scenes_scene_extends_boundary() {
        // Scene segment close to silence boundary extends it
        let silences = vec![Segment {
            start: 1.0,
            end: 3.0,
        }];
        // Scene at 0.7s creates a segment from 0.7 to 1.7 (assuming 1s default)
        // The scene start (0.7) is within 0.5s of silence start (1.0), so silence start extends to 0.7
        let scenes = vec![0.7];
        let merged = merge_silences_and_scenes(&silences, &scenes, 10.0);
        assert_eq!(merged.len(), 1);
        // Scene at 0.7 creates segment [0.7, 1.7], which extends silence start from 1.0 to 0.7
        assert_eq!(merged[0].start, 0.7);
        assert_eq!(merged[0].end, 3.0);
    }

    #[test]
    fn test_merge_silences_and_scenes_no_overlap() {
        // Silences and scenes with no overlap should not affect each other
        let silences = vec![Segment {
            start: 1.0,
            end: 2.0,
        }];
        // Scene at 5.0 is far from silence
        let scenes = vec![5.0];
        let merged = merge_silences_and_scenes(&silences, &scenes, 10.0);
        assert_eq!(merged.len(), 1);
        assert_eq!(
            merged[0],
            Segment {
                start: 1.0,
                end: 2.0
            }
        );
    }

    #[test]
    fn test_merge_silences_and_scenes_complex_overlap() {
        // Multiple silences and scenes with complex interactions
        // Scene boundaries close to silence edges cause extension
        let silences = vec![
            Segment {
                start: 1.0,
                end: 3.0,
            },
            Segment {
                start: 6.0,
                end: 8.0,
            },
        ];
        // Scene at 0.8 is close to first silence start (diff=0.2 < 0.5)
        // Scene at 3.2 is close to first silence end (diff=0.2 < 0.5)
        // Scene at 5.8 is close to second silence start (diff=0.2 < 0.5)
        // Scene at 8.2 is close to second silence end (diff=0.2 < 0.5)
        let scenes = vec![0.8, 3.2, 5.8, 8.2];
        let merged = merge_silences_and_scenes(&silences, &scenes, 10.0);
        assert_eq!(merged.len(), 2);
        // First silence extended by scene boundaries
        assert_eq!(
            merged[0],
            Segment {
                start: 0.8,
                end: 3.2
            }
        );
        // Second silence extended by scene boundaries
        assert_eq!(
            merged[1],
            Segment {
                start: 5.8,
                end: 8.2
            }
        );
    }

    #[test]
    fn test_format_batch_summary_basic() {
        let s = format_batch_summary(10, 7, 2, 1);
        // Should contain ANSI color codes
        assert!(s.contains("\x1b[32m"), "missing green color code");
        assert!(s.contains("\x1b[31m"), "missing red color code");
        assert!(s.contains("\x1b[33m"), "missing yellow color code");
        assert!(s.contains("\x1b[0m"), "missing reset color code");
        // Should contain the values
        assert!(s.contains("7"), "missing successful count");
        assert!(s.contains("2"), "missing failed count");
        assert!(s.contains("1"), "missing skipped count");
        // Should contain percentages
        assert!(s.contains("70%"), "missing success percentage");
        assert!(s.contains("20%"), "missing failure percentage");
    }

    #[test]
    fn test_format_batch_summary_zero_division() {
        // Edge case: total = 0 should not panic
        let s = format_batch_summary(0, 0, 0, 0);
        assert!(s.contains("BATCH SUMMARY"));
        // Percentages should be 0 when total is 0
        assert!(s.contains("0%"));
    }

    #[test]
    fn test_format_batch_summary_large_numbers() {
        let s = format_batch_summary(100000, 99999, 1, 0);
        // Should right-align large numbers
        assert!(s.contains("99999"));
        assert!(s.contains("100000"));
        // Percentage calculations should be correct
        assert!(s.contains("99%") || s.contains("100%"));
    }

    #[test]
    fn test_format_batch_summary_all_success() {
        let s = format_batch_summary(5, 5, 0, 0);
        assert!(s.contains("100%"), "expected 100% success rate");
        assert!(s.contains("0%"), "expected 0% failure rate");
    }

    // ── Pure logic tests (no FFmpeg needed) ─────────────────────────────────

    #[test]
    fn test_segment_gap_detection() {
        use crate::analyzer::Segment;

        let seg1 = Segment {
            start: 0.0,
            end: 10.0,
        };
        let seg2 = Segment {
            start: 15.0,
            end: 25.0,
        };

        // Gap between segments
        let gap = seg2.start - seg1.end;
        assert_eq!(gap, 5.0, "There should be a 5s gap between segments");
    }

    #[test]
    fn test_segment_total_duration() {
        use crate::analyzer::ProcessedSegment;

        let segments = vec![
            ProcessedSegment {
                start: 0.0,
                end: 10.0,
                speed: 1.0,
            },
            ProcessedSegment {
                start: 10.0,
                end: 25.0,
                speed: 1.0,
            },
            ProcessedSegment {
                start: 25.0,
                end: 40.0,
                speed: 1.0,
            },
        ];

        let total_duration: f32 = segments.iter().map(|s| s.end - s.start).sum();

        assert!((total_duration - 40.0).abs() < 1e-6);
    }

    // ── Batch progress edge cases ──────────────────────────────────────────
    #[test]
    fn test_format_batch_summary_empty_stats() {
        let s = format_batch_summary(0, 0, 0, 0);
        // Should not panic and should show 0% rates
        assert!(s.contains("0%"));
    }

    #[test]
    fn test_format_batch_summary_all_failed() {
        let s = format_batch_summary(5, 0, 0, 5);
        // 0% success, 100% failure
        assert!(s.contains("0%") || s.contains("100%"));
    }

    #[test]
    fn test_merge_silences_scenes_empty_both() {
        // Both silences and scenes empty
        let silences: Vec<crate::analyzer::Segment> = vec![];
        let scenes: Vec<f32> = vec![];
        let result = merge_silences_and_scenes(&silences, &scenes, 60.0);
        // Should return empty (scenes is empty so return silences as-is)
        assert!(result.is_empty());
    }

    #[test]
    fn test_merge_silences_scenes_single_scene() {
        let silences: Vec<crate::analyzer::Segment> = vec![];
        let scenes = vec![30.0]; // Single scene at 30s
        let result = merge_silences_and_scenes(&silences, &scenes, 60.0);
        // When silences is empty, the function returns empty vec (early return)
        // This is expected behavior - silences drive the output
        assert!(result.is_empty() || result.len() == 2);
    }

    // ── BatchProcessor edge cases ──────────────────────────────────────────
    #[test]
    fn test_merge_silences_multiple_markers() {
        let silences = vec![
            crate::analyzer::Segment {
                start: 10.0,
                end: 20.0,
            },
            crate::analyzer::Segment {
                start: 30.0,
                end: 40.0,
            },
        ];
        let scenes: Vec<f32> = vec![15.0, 35.0];
        let result = merge_silences_and_scenes(&silences, &scenes, 60.0);
        // Result depends on overlap handling
        assert!(result.len() >= 0);
    }

    #[test]
    fn test_merge_silences_at_start_and_end() {
        let silences = vec![
            crate::analyzer::Segment {
                start: 0.0,
                end: 5.0,
            }, // Start
            crate::analyzer::Segment {
                start: 55.0,
                end: 60.0,
            }, // End
        ];
        let scenes: Vec<f32> = vec![];
        let result = merge_silences_and_scenes(&silences, &scenes, 60.0);
        // With no scenes, result equals silences
        assert_eq!(result.len(), silences.len());
    }

    #[test]
    fn test_merge_silences_does_not_overlap() {
        let silences = vec![
            crate::analyzer::Segment {
                start: 10.0,
                end: 20.0,
            },
            crate::analyzer::Segment {
                start: 30.0,
                end: 40.0,
            },
        ];
        let scenes: Vec<f32> = vec![];
        let result = merge_silences_and_scenes(&silences, &scenes, 60.0);
        // Segments don't overlap
        for seg in &result {
            assert!(seg.end - seg.start > 0.0);
        }
    }

    #[test]
    fn test_batch_summary_format_types() {
        // Verify format_batch_summary returns valid strings
        let s1 = format_batch_summary(0, 0, 0, 0);
        let s2 = format_batch_summary(10, 5, 3, 2);
        let s3 = format_batch_summary(100, 50, 30, 20);

        // All should be non-empty strings
        assert!(!s1.is_empty());
        assert!(!s2.is_empty());
        assert!(!s3.is_empty());
    }

    // ── BatchProcessor edge cases ──────────────────────────────────────────
    #[test]
    fn test_merge_silences_gap_calculation() {
        let silences = vec![
            crate::analyzer::Segment {
                start: 0.0,
                end: 5.0,
            },
            crate::analyzer::Segment {
                start: 10.0,
                end: 15.0,
            },
        ];
        // Gap between silences
        let gap = silences[1].start - silences[0].end;
        assert!((gap - 5.0).abs() < 1e-6);
    }

    #[test]
    fn test_merge_silences_total_removed() {
        let silences = vec![
            crate::analyzer::Segment {
                start: 5.0,
                end: 10.0,
            },
            crate::analyzer::Segment {
                start: 20.0,
                end: 25.0,
            },
        ];
        let total_removed: f32 = silences.iter().map(|s| s.end - s.start).sum();
        // Total removed is 10 seconds
        assert!((total_removed - 10.0).abs() < 1e-6);
    }

    #[test]
    fn test_merge_silences_sequential() {
        let silences = vec![
            crate::analyzer::Segment {
                start: 0.0,
                end: 5.0,
            },
            crate::analyzer::Segment {
                start: 5.0,
                end: 10.0,
            },
            crate::analyzer::Segment {
                start: 10.0,
                end: 15.0,
            },
        ];
        // Sequential silences form continuous region
        let total: f32 = silences.iter().map(|s| s.end - s.start).sum();
        assert!((total - 15.0).abs() < 1e-6);
    }

    #[test]
    fn test_batch_progress_insertion() {
        let mut progress = BatchProgress::default();
        progress.total = 5;
        progress.completed.insert(PathBuf::from("/a.mp4"), 100);
        progress.completed.insert(PathBuf::from("/b.mp4"), 200);
        assert_eq!(progress.completed.len(), 2);
    }

    #[test]
    fn test_batch_progress_retains_insertion_order() {
        let mut progress = BatchProgress::default();
        progress.total = 3;
        progress.completed.insert(PathBuf::from("/first.mp4"), 100);
        progress.completed.insert(PathBuf::from("/second.mp4"), 200);
        progress.completed.insert(PathBuf::from("/third.mp4"), 300);
        // HashMap doesn't guarantee order, but we can check count
        assert_eq!(progress.completed.len(), 3);
    }

    // ── BatchProgress final edge cases ──────────────────────────────────
    #[test]
    fn test_batch_progress_completion_rate() {
        let mut progress = BatchProgress::default();
        progress.total = 10;
        for i in 0..5 {
            progress
                .completed
                .insert(PathBuf::from(format!("/{}.mp4", i)), 100);
        }
        // Half completed
        assert_eq!(progress.completed.len(), 5);
        assert_eq!(progress.completed.len(), progress.total / 2);
    }

    #[test]
    fn test_batch_progress_clear_state() {
        let mut progress = BatchProgress::default();
        progress.total = 5;
        progress.completed.insert(PathBuf::from("/a.mp4"), 100);
        progress.failed.insert(PathBuf::from("/b.mp4"));
        // State before clearing
        assert_eq!(progress.completed.len() + progress.failed.len(), 2);
        // Reset would require new instance
        let new_progress = BatchProgress::default();
        assert!(new_progress.completed.is_empty());
    }

    #[test]
    fn test_batch_progress_zero_total() {
        let mut progress = BatchProgress::default();
        progress.total = 0;
        // Zero total is valid
        assert_eq!(progress.total, 0);
        assert!(progress.completed.is_empty());
    }

    #[test]
    fn test_batch_progress_completed_timing_values() {
        let mut progress = BatchProgress::default();
        progress.total = 2;
        progress.completed.insert(PathBuf::from("/a.mp4"), 100);
        progress.completed.insert(PathBuf::from("/b.mp4"), 200);
        // Check timing values are captured
        let total_time: u128 = progress.completed.values().map(|v| *v as u128).sum();
        assert_eq!(total_time, 300);
    }
}