subx-cli 1.6.0

//! Refactored sync command supporting new multi-method sync engine.
//!
//! This module provides the synchronization command functionality, supporting
//! multiple synchronization methods including local VAD (Voice Activity Detection),
//! automatic method selection, and manual offset adjustment.

use crate::cli::SyncArgs;
use crate::cli::SyncMode;
use crate::cli::sync_args::create_default_output_path;
use crate::config::Config;
use crate::config::ConfigService;
use crate::core::formats::manager::FormatManager;
use crate::core::sync::{SyncEngine, SyncMethod, SyncResult};
use crate::{Result, error::SubXError};

/// Internal helper to perform a single video-subtitle synchronization.
async fn run_single(
    args: &SyncArgs,
    config: &Config,
    sync_engine: &SyncEngine,
    format_manager: &FormatManager,
) -> Result<()> {
    let subtitle_path = args.subtitle.as_ref().ok_or_else(|| {
        SubXError::CommandExecution(
            "Subtitle file path is required for single file sync".to_string(),
        )
    })?;

    if args.verbose {
        println!("🎬 Loading subtitle file: {}", subtitle_path.display());
        println!("📄 Subtitle entries count: {}", {
            let s = format_manager.load_subtitle(subtitle_path).map_err(|e| {
                eprintln!("[DEBUG] Failed to load subtitle: {e}");
                e
            })?;
            s.entries.len()
        });
    }
    let mut subtitle = format_manager.load_subtitle(subtitle_path).map_err(|e| {
        eprintln!("[DEBUG] Failed to load subtitle: {e}");
        e
    })?;
    let sync_result = if let Some(offset) = args.offset {
        if args.verbose {
            println!("⚙️  Using manual offset: {offset:.3}s");
        }
        sync_engine
            .apply_manual_offset(&mut subtitle, offset)
            .map_err(|e| {
                eprintln!("[DEBUG] Failed to apply manual offset: {e}");
                e
            })?;
        SyncResult {
            offset_seconds: offset,
            confidence: 1.0,
            method_used: crate::core::sync::SyncMethod::Manual,
            correlation_peak: 0.0,
            processing_duration: std::time::Duration::ZERO,
            warnings: Vec::new(),
            additional_info: None,
        }
    } else {
        // Automatic sync requires video file
        let video_path = args.video.as_ref().ok_or_else(|| {
            SubXError::CommandExecution(
                "Video file path is required for automatic sync".to_string(),
            )
        })?;

        // Check if video path is empty (manual mode case)
        if video_path.as_os_str().is_empty() {
            return Err(SubXError::CommandExecution(
                "Video file path is required for automatic sync".to_string(),
            ));
        }

        let method = determine_sync_method(args, &config.sync.default_method)?;
        if args.verbose {
            println!("🔍 Starting sync analysis...");
            println!("   Method: {method:?}");
            println!("   Analysis window: {}s", args.window);
            println!("   Video file: {}", video_path.display());
        }
        let mut sync_cfg = config.sync.clone();
        apply_cli_overrides(&mut sync_cfg, args)?;
        let result = sync_engine
            .detect_sync_offset(video_path.as_path(), &subtitle, Some(method))
            .await
            .map_err(|e| {
                eprintln!("[DEBUG] Failed to detect sync offset: {e}");
                e
            })?;
        if args.verbose {
            println!("✅ Analysis completed:");
            println!("   Detected offset: {:.3}s", result.offset_seconds);
            println!("   Confidence: {:.1}%", result.confidence * 100.0);
            println!("   Processing time: {:?}", result.processing_duration);
        }
        if !args.dry_run {
            sync_engine
                .apply_manual_offset(&mut subtitle, result.offset_seconds)
                .map_err(|e| {
                    eprintln!("[DEBUG] Failed to apply detected offset: {e}");
                    e
                })?;
        }
        result
    };
    display_sync_result(&sync_result, args.verbose);
    if !args.dry_run {
        if let Some(out) = args.get_output_path() {
            if out.exists() && !args.force {
                eprintln!(
                    "[DEBUG] Output file exists and --force not set: {}",
                    out.display()
                );
                return Err(SubXError::CommandExecution(format!(
                    "Output file already exists: {}. Use --force to overwrite.",
                    out.display()
                )));
            }
            format_manager.save_subtitle(&subtitle, &out).map_err(|e| {
                eprintln!("[DEBUG] Failed to save subtitle: {e}");
                e
            })?;
            if args.verbose {
                println!("💾 Synchronized subtitle saved to: {}", out.display());
            } else {
                println!("Synchronized subtitle saved to: {}", out.display());
            }
        } else {
            eprintln!("[DEBUG] No output path specified");
            return Err(SubXError::CommandExecution(
                "No output path specified".to_string(),
            ));
        }
    } else {
        println!("🔍 Dry run mode - file not saved");
    }
    Ok(())
}

/// Execute the sync command with the provided arguments.
///
/// This function handles both manual offset synchronization and automatic
/// synchronization using various detection methods.
///
/// # Arguments
///
/// * `args` - The sync command arguments containing input files and options
/// * `config_service` - Service for accessing configuration settings
///
/// # Returns
///
/// Returns `Ok(())` on successful synchronization, or an error if the operation fails
///
/// # Errors
///
/// This function returns an error if:
/// - Arguments validation fails
/// - Subtitle file cannot be loaded
/// - Video file is required but not provided for automatic sync
/// - Output file already exists and force flag is not set
/// - Synchronization detection fails
///
/// Execute the sync command with the provided arguments.
///
/// Handles both single and batch synchronization modes.
pub async fn execute(args: SyncArgs, config_service: &dyn ConfigService) -> Result<()> {
    // Validate arguments and prepare resources
    if let Err(msg) = args.validate() {
        return Err(SubXError::CommandExecution(msg));
    }
    let config = config_service.get_config()?;

    // Validate manual offset against max_offset_seconds configuration
    if let Some(manual_offset) = args.offset {
        if manual_offset.abs() > config.sync.max_offset_seconds {
            return Err(SubXError::config(format!(
                "The specified offset {:.2}s exceeds the configured maximum allowed value {:.2}s.\n\n\
                Please use one of the following methods to resolve this issue:\n\
                1. Use a smaller offset: --offset {:.2}\n\
                2. Adjust configuration: subx-cli config set sync.max_offset_seconds {:.2}\n\
                3. Use automatic detection: remove the --offset parameter",
                manual_offset,
                config.sync.max_offset_seconds,
                config.sync.max_offset_seconds * 0.9, // Recommended value slightly below limit
                manual_offset
                    .abs()
                    .max(config.sync.max_offset_seconds * 1.5) // Recommend increasing to appropriate value
            )));
        }
    }

    let sync_engine = SyncEngine::new(config.sync.clone())?;
    let format_manager = FormatManager::new();

    // Batch mode: multiple video-subtitle pairs
    if let Ok(SyncMode::Batch(handler)) = args.get_sync_mode() {
        let paths = handler
            .collect_files()
            .map_err(|e| SubXError::CommandExecution(e.to_string()))?;

        // Separate video and subtitle files
        let video_files: Vec<_> = paths
            .iter()
            .filter(|p| {
                p.extension()
                    .and_then(|s| s.to_str())
                    .map(|e| ["mp4", "mkv", "avi", "mov"].contains(&e.to_lowercase().as_str()))
                    .unwrap_or(false)
            })
            .collect();

        let subtitle_files: Vec<_> = paths
            .iter()
            .filter(|p| {
                p.extension()
                    .and_then(|s| s.to_str())
                    .map(|e| ["srt", "ass", "vtt", "sub"].contains(&e.to_lowercase().as_str()))
                    .unwrap_or(false)
            })
            .collect();

        // Case 1: No video files - skip all subtitles
        if video_files.is_empty() {
            for sub_path in &subtitle_files {
                println!(
                    "✗ Skip sync for {}: no video files found in directory",
                    sub_path.display()
                );
            }
            return Ok(());
        }

        // Case 2: Exactly one video and one subtitle - sync regardless of name match
        if video_files.len() == 1 && subtitle_files.len() == 1 {
            let mut single_args = args.clone();
            single_args.input_paths.clear();
            single_args.batch = None;
            single_args.recursive = false;
            single_args.video = Some(video_files[0].clone());
            single_args.subtitle = Some(subtitle_files[0].clone());
            // If subtitle came from an archive, redirect output beside the archive
            if single_args.output.is_none() {
                if let Some(archive_path) = paths.archive_origin(subtitle_files[0]) {
                    if let Some(archive_dir) = archive_path.parent() {
                        let default = create_default_output_path(subtitle_files[0]);
                        if let Some(filename) = default.file_name() {
                            single_args.output = Some(archive_dir.join(filename));
                        }
                    }
                }
            }
            run_single(&single_args, &config, &sync_engine, &format_manager).await?;
            return Ok(());
        }

        // Case 3: Multiple videos/subtitles - match by prefix and handle unmatched
        let mut processed_videos = std::collections::HashSet::new();
        let mut processed_subtitles = std::collections::HashSet::new();

        // Process subtitle files with matching videos
        for sub_path in &subtitle_files {
            let sub_name = sub_path.file_stem().and_then(|s| s.to_str()).unwrap_or("");
            let sub_dir = sub_path.parent();

            let matching_video = video_files.iter().find(|&video_path| {
                let video_name = video_path
                    .file_stem()
                    .and_then(|s| s.to_str())
                    .unwrap_or("");
                let video_dir = video_path.parent();

                // Check if they are in the same directory
                if sub_dir != video_dir {
                    return false;
                }

                // If in the same directory, check if it's a 1-to-1 pair
                let dir_videos: Vec<_> = video_files
                    .iter()
                    .filter(|v| v.parent() == video_dir)
                    .collect();
                let dir_subtitles: Vec<_> = subtitle_files
                    .iter()
                    .filter(|s| s.parent() == sub_dir)
                    .collect();

                if dir_videos.len() == 1 && dir_subtitles.len() == 1 {
                    // 1-to-1 in same directory - always match
                    return true;
                }

                // Otherwise use starts_with logic
                !video_name.is_empty() && sub_name.starts_with(video_name)
            });

            if let Some(video_path) = matching_video {
                let mut single_args = args.clone();
                single_args.input_paths.clear();
                single_args.batch = None;
                single_args.recursive = false;
                single_args.video = Some((*video_path).clone());
                single_args.subtitle = Some((*sub_path).clone());
                // If subtitle came from an archive, redirect output beside the archive
                if single_args.output.is_none() {
                    if let Some(archive_path) = paths.archive_origin(sub_path) {
                        if let Some(archive_dir) = archive_path.parent() {
                            let default = create_default_output_path(sub_path);
                            if let Some(filename) = default.file_name() {
                                single_args.output = Some(archive_dir.join(filename));
                            }
                        }
                    }
                }
                run_single(&single_args, &config, &sync_engine, &format_manager).await?;

                processed_videos.insert(video_path.as_path());
                processed_subtitles.insert(sub_path.as_path());
            }
        }

        // Display skip messages for unmatched videos
        for video_path in &video_files {
            if !processed_videos.contains(video_path.as_path()) {
                println!(
                    "✗ Skip sync for {}: no matching subtitle",
                    video_path.display()
                );
            }
        }

        // Display skip messages for unmatched subtitles
        for sub_path in &subtitle_files {
            if !processed_subtitles.contains(sub_path.as_path()) {
                println!("✗ Skip sync for {}: no matching video", sub_path.display());
            }
        }

        return Ok(());
    }

    // Single mode or error
    match args.get_sync_mode() {
        Ok(SyncMode::Single { video, subtitle }) => {
            // Update args with the resolved paths from SyncMode
            let mut resolved_args = args.clone();
            if !video.as_os_str().is_empty() {
                resolved_args.video = Some(video.clone());
            }
            resolved_args.subtitle = Some(subtitle.clone());
            // For subtitle-only sync without offset, default to zero manual offset
            if resolved_args.video.is_none() && resolved_args.offset.is_none() {
                resolved_args.offset = Some(0.0);
                resolved_args.method = Some(crate::cli::SyncMethodArg::Manual);
            }
            run_single(&resolved_args, &config, &sync_engine, &format_manager).await?;
            Ok(())
        }
        Err(err) => Err(err),
        _ => unreachable!(),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::config::TestConfigService;
    use std::fs;
    use std::sync::Arc;
    use tempfile::TempDir;

    #[tokio::test]
    async fn test_sync_batch_processing() -> Result<()> {
        // Prepare test configuration
        let config_service = Arc::new(TestConfigService::with_sync_settings(0.5, 30.0));

        // Create temporary directory with video and subtitle files
        let tmp = TempDir::new().unwrap();
        let video1 = tmp.path().join("movie1.mp4");
        let sub1 = tmp.path().join("movie1.srt");
        fs::write(&video1, b"").unwrap();
        fs::write(&sub1, b"1\n00:00:01,000 --> 00:00:02,000\nTest1\n\n").unwrap();

        // Test single file sync instead of batch to avoid audio processing issues
        let args = SyncArgs {
            positional_paths: Vec::new(),
            video: Some(video1.clone()),
            subtitle: Some(sub1.clone()),
            input_paths: vec![],
            recursive: false,
            offset: Some(1.0), // Use manual offset to avoid audio processing
            method: Some(crate::cli::SyncMethodArg::Manual),
            window: 30,
            vad_sensitivity: None,
            output: None,
            verbose: false,
            dry_run: true, // Use dry run to avoid file creation
            force: true,
            batch: None, // Disable batch mode,
            no_extract: false,
        };

        execute(args, config_service.as_ref()).await?;

        // In dry run mode, files are not actually created, so we just verify the command executed successfully
        Ok(())
    }
}

/// Maintain consistency with other commands
pub async fn execute_with_config(
    args: SyncArgs,
    config_service: std::sync::Arc<dyn ConfigService>,
) -> Result<()> {
    execute(args, config_service.as_ref()).await
}

/// Determine the sync method to use based on CLI arguments and configuration.
///
/// # Arguments
///
/// * `args` - CLI arguments which may specify a sync method
/// * `default_method` - Default method from configuration
///
/// # Returns
///
/// The determined sync method to use
fn determine_sync_method(args: &SyncArgs, default_method: &str) -> Result<SyncMethod> {
    // If CLI specifies a method, use it
    if let Some(ref method_arg) = args.method {
        return Ok(method_arg.clone().into());
    }
    // If VAD sensitivity specified, default to VAD method
    if args.vad_sensitivity.is_some() {
        return Ok(SyncMethod::LocalVad);
    }
    // Otherwise use the default method from configuration
    match default_method {
        "vad" => Ok(SyncMethod::LocalVad),
        "auto" => Ok(SyncMethod::Auto),
        _ => Ok(SyncMethod::Auto),
    }
}

/// Apply CLI argument overrides to the sync configuration.
///
/// # Arguments
///
/// * `config` - Sync configuration to modify
/// * `args` - CLI arguments containing overrides
fn apply_cli_overrides(config: &mut crate::config::SyncConfig, args: &SyncArgs) -> Result<()> {
    // Apply VAD-specific overrides
    if let Some(sensitivity) = args.vad_sensitivity {
        config.vad.sensitivity = sensitivity;
    }

    Ok(())
}

/// Display sync result information to the user.
///
/// # Arguments
///
/// * `result` - The sync result to display
/// * `verbose` - Whether to show detailed information
fn display_sync_result(result: &SyncResult, verbose: bool) {
    if verbose {
        println!("\n=== Sync Results ===");
        println!("Method used: {:?}", result.method_used);
        println!("Detected offset: {:.3} seconds", result.offset_seconds);
        println!("Confidence: {:.1}%", result.confidence * 100.0);
        println!("Processing time: {:?}", result.processing_duration);

        if !result.warnings.is_empty() {
            println!("\nWarnings:");
            for warning in &result.warnings {
                println!("  ⚠️  {warning}");
            }
        }

        if let Some(info) = &result.additional_info {
            if let Ok(pretty_info) = serde_json::to_string_pretty(info) {
                println!("\nAdditional information:");
                println!("{pretty_info}");
            }
        }
    } else {
        println!(
            "✅ Sync completed: offset {:.3}s (confidence: {:.1}%)",
            result.offset_seconds,
            result.confidence * 100.0
        );
    }
}