subx_cli/commands/

convert_command.rs

//! Subtitle format conversion command implementation.
//!
//! This module provides comprehensive subtitle format conversion capabilities,
//! transforming subtitle files between different standards while preserving
//! timing information, styling, and encoding. It supports both single file
//! and batch directory processing with intelligent format detection.
//!
//! # Supported Conversions
//!
//! The conversion system supports transformation between major subtitle formats:
//!
//! ## Input Formats (Auto-detected)
//! - **SRT (SubRip)**: Most common subtitle format
//! - **ASS/SSA (Advanced SubStation Alpha)**: Rich formatting support
//! - **VTT (WebVTT)**: Web-optimized subtitle format
//! - **SUB (MicroDVD)**: Frame-based subtitle format
//! - **SMI (SAMI)**: Microsoft subtitle format
//! - **LRC (Lyrics)**: Simple lyric format
//!
//! ## Output Formats (User-specified)
//! - **SRT**: Universal compatibility and simplicity
//! - **ASS**: Advanced styling and positioning
//! - **VTT**: HTML5 video and web applications
//! - **SUB**: Legacy system compatibility
//!
//! # Conversion Features
//!
//! - **Format Detection**: Automatic input format recognition
//! - **Styling Preservation**: Maintain formatting where possible
//! - **Encoding Conversion**: Handle various character encodings
//! - **Batch Processing**: Convert multiple files efficiently
//! - **Quality Validation**: Verify output format integrity
//! - **Backup Creation**: Preserve original files optionally
//!
//! # Quality Assurance
//!
//! Each conversion undergoes comprehensive validation:
//! - **Timing Integrity**: Verify timestamp accuracy and ordering
//! - **Content Preservation**: Ensure no text loss during conversion
//! - **Format Compliance**: Validate output meets format specifications
//! - **Encoding Correctness**: Verify character encoding consistency
//! - **Styling Translation**: Map styles between format capabilities
//!
//! # Examples
//!
//! ```rust,ignore
//! use subx_cli::cli::{ConvertArgs, OutputSubtitleFormat};
//! use subx_cli::commands::convert_command;
//! use std::path::PathBuf;
//!
//! // Convert single SRT file to ASS format
//! let args = ConvertArgs {
//!     input: PathBuf::from("input.srt"),
//!     format: Some(OutputSubtitleFormat::Ass),
//!     output: Some(PathBuf::from("output.ass")),
//!     keep_original: true,
//!     encoding: "utf-8".to_string(),
//! };
//!
//! convert_command::execute(args).await?;
//!
//! // Batch convert directory with default settings
//! let batch_args = ConvertArgs {
//!     input: PathBuf::from("./subtitles/"),
//!     format: Some(OutputSubtitleFormat::Vtt),
//!     output: None, // Use default naming
//!     keep_original: true,
//!     encoding: "utf-8".to_string(),
//! };
//!
//! convert_command::execute(batch_args).await?;
//! ```

use std::path::{Path, PathBuf};

use serde::Serialize;

use crate::cli::output::{active_mode, emit_success};
use crate::cli::{ConvertArgs, OutputSubtitleFormat};
use crate::config::ConfigService;
use crate::core::file_manager::FileManager;
use crate::core::formats::converter::{ConversionConfig, FormatConverter};
use crate::error::SubXError;

// ─── JSON payload types (machine-readable-output capability) ─────────────

/// Per-item error embedded in [`ConvertItem::error`].
///
/// Mirrors the top-level error envelope's `error` field minus
/// `exit_code` (per the `machine-readable-output` spec's "Per-Item
/// Status Semantics" requirement).
#[derive(Debug, Serialize)]
pub struct ConvertItemError {
    /// Stable snake_case category from [`crate::error::SubXError::category`].
    pub category: String,
    /// Stable upper-snake-case machine code from
    /// [`crate::error::SubXError::machine_code`].
    pub code: String,
    /// Human-readable message (English).
    pub message: String,
}

impl ConvertItemError {
    fn from_error(err: &SubXError) -> Self {
        Self {
            category: err.category().to_string(),
            code: err.machine_code().to_string(),
            message: err.user_friendly_message(),
        }
    }

    fn synthetic(category: &str, code: &str, message: String) -> Self {
        Self {
            category: category.to_string(),
            code: code.to_string(),
            message,
        }
    }
}

/// Per-file conversion record emitted in the `data.conversions` array
/// of the JSON envelope.
///
/// Field naming follows
/// `openspec/changes/add-machine-readable-output/specs/format-conversion/spec.md`.
/// `entry_count` is an additive enrichment (subtitle entries serialized
/// to the output) that consumers MAY ignore on older schema versions.
#[derive(Debug, Serialize)]
pub struct ConvertItem {
    /// Source file path as provided to the converter.
    pub input: String,
    /// Resolved output file path.
    pub output: String,
    /// Lowercase source format identifier (e.g. `"srt"`, `"ass"`,
    /// `"vtt"`, `"sub"`). `null` when the file failed before parsing.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_format: Option<String>,
    /// Lowercase target format identifier.
    pub target_format: String,
    /// Output encoding label (e.g. `"UTF-8"`).
    pub encoding: String,
    /// Whether the conversion was applied to disk.
    pub applied: bool,
    /// Number of subtitle entries successfully converted, when known.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub entry_count: Option<usize>,
    /// `"ok"` or `"error"`.
    pub status: &'static str,
    /// Populated only when `status == "error"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<ConvertItemError>,
}

/// Top-level `data` payload for `convert` in JSON mode.
#[derive(Debug, Serialize)]
pub struct ConvertPayload {
    /// One entry per processed file (single-input invocations produce a
    /// single-element array).
    pub conversions: Vec<ConvertItem>,
}

/// Execute subtitle format conversion with comprehensive validation and error handling.
///
/// This function orchestrates the complete conversion workflow, from configuration
/// loading through final output validation. It supports both single file and batch
/// directory processing with intelligent format detection and preservation of
/// subtitle quality.
///
/// # Conversion Process
///
/// 1. **Configuration Loading**: Load application and conversion settings
/// 2. **Format Detection**: Automatically detect input subtitle format
/// 3. **Conversion Setup**: Configure converter with user preferences
/// 4. **Processing**: Transform subtitle content to target format
/// 5. **Validation**: Verify output quality and format compliance
/// 6. **File Management**: Handle backups and output file creation
///
/// # Format Mapping
///
/// The conversion process intelligently maps features between formats:
///
/// ## SRT to ASS
/// - Basic text → Advanced styling capabilities
/// - Simple timing → Precise timing control
/// - Limited formatting → Rich formatting options
///
/// ## ASS to SRT
/// - Rich styling → Basic formatting preservation
/// - Advanced timing → Standard timing format
/// - Complex layouts → Simplified text positioning
///
/// ## Any to VTT
/// - Format-specific features → Web-compatible equivalents
/// - Custom styling → CSS-like styling syntax
/// - Traditional timing → WebVTT timing format
///
/// # Configuration Integration
///
/// The function respects multiple configuration sources:
/// ```toml
/// [formats]
/// default_output = "srt"           # Default output format
/// preserve_styling = true          # Maintain formatting where possible
/// validate_output = true           # Perform output validation
/// backup_enabled = true            # Create backups before conversion
/// ```
///
/// # Arguments
///
/// * `args` - Conversion arguments containing:
///   - `input`: Source file or directory path
///   - `format`: Target output format (SRT, ASS, VTT, SUB)
///   - `output`: Optional output path (auto-generated if not specified)
///   - `keep_original`: Whether to preserve original files
///   - `encoding`: Character encoding for input/output files
///
/// # Returns
///
/// Returns `Ok(())` on successful conversion, or an error describing:
/// - Configuration loading failures
/// - Input file access or format problems
/// - Conversion processing errors
/// - Output file creation or validation issues
///
/// # Error Handling
///
/// Comprehensive error handling covers:
/// - **Input Validation**: File existence, format detection, accessibility
/// - **Processing Errors**: Conversion failures, content corruption
/// - **Output Issues**: Write permissions, disk space, format validation
/// - **Configuration Problems**: Invalid settings, missing dependencies
///
/// # File Safety
///
/// The conversion process ensures file safety through:
/// - **Atomic Operations**: Complete conversion or no changes
/// - **Backup Creation**: Original files preserved when requested
/// - **Validation**: Output quality verification before finalization
/// - **Rollback Capability**: Ability to undo changes if problems occur
///
/// # Examples
///
/// ```rust,ignore
/// use subx_cli::cli::{ConvertArgs, OutputSubtitleFormat};
/// use subx_cli::commands::convert_command;
/// use std::path::PathBuf;
///
/// // Convert with explicit output path
/// let explicit_args = ConvertArgs {
///     input: PathBuf::from("movie.srt"),
///     format: Some(OutputSubtitleFormat::Ass),
///     output: Some(PathBuf::from("movie_styled.ass")),
///     keep_original: true,
///     encoding: "utf-8".to_string(),
/// };
/// convert_command::execute(explicit_args).await?;
///
/// // Convert with automatic output naming
/// let auto_args = ConvertArgs {
///     input: PathBuf::from("episode.srt"),
///     format: Some(OutputSubtitleFormat::Vtt),
///     output: None, // Will become "episode.vtt"
///     keep_original: false,
///     encoding: "utf-8".to_string(),
/// };
/// convert_command::execute(auto_args).await?;
///
/// // Batch convert directory
/// let batch_args = ConvertArgs {
///     input: PathBuf::from("./season1_subtitles/"),
///     format: Some(OutputSubtitleFormat::Srt),
///     output: None,
///     keep_original: true,
///     encoding: "utf-8".to_string(),
/// };
/// convert_command::execute(batch_args).await?;
/// ```
///
/// # Performance Considerations
///
/// - **Memory Efficiency**: Streaming processing for large subtitle files
/// - **Disk I/O Optimization**: Efficient file access patterns
/// - **Batch Processing**: Optimized for multiple file operations
/// - **Validation Caching**: Avoid redundant quality checks
pub async fn execute(args: ConvertArgs, config_service: &dyn ConfigService) -> crate::Result<()> {
    // Load application configuration for conversion settings
    let app_config = config_service.get_config()?;

    // Configure conversion engine with user preferences and application defaults
    let config = ConversionConfig {
        preserve_styling: app_config.formats.preserve_styling,
        target_encoding: args.encoding.clone(),
        keep_original: args.keep_original,
        validate_output: true,
    };
    let converter = FormatConverter::new(config);

    // Determine output format from arguments or configuration defaults
    let default_output = match app_config.formats.default_output.as_str() {
        "srt" => OutputSubtitleFormat::Srt,
        "ass" => OutputSubtitleFormat::Ass,
        "vtt" => OutputSubtitleFormat::Vtt,
        "sub" => OutputSubtitleFormat::Sub,
        other => {
            return Err(SubXError::config(format!(
                "Unknown default output format: {other}"
            )));
        }
    };
    let output_format = args.format.clone().unwrap_or(default_output);

    // Collect input files using InputPathHandler
    let handler = args
        .get_input_handler()
        .map_err(|e| SubXError::CommandExecution(e.to_string()))?;
    let collected = handler
        .collect_files()
        .map_err(|e| SubXError::CommandExecution(e.to_string()))?;
    if collected.is_empty() {
        // Nothing to do — emit an empty success envelope in JSON mode so
        // callers always receive a valid document.
        let mode = active_mode();
        if mode.is_json() {
            emit_success(
                mode,
                "convert",
                ConvertPayload {
                    conversions: Vec::new(),
                },
            );
        }
        return Ok(());
    }

    let mode = active_mode();
    let json_mode = mode.is_json();
    let single_input = collected.len() == 1;

    // Accumulate per-file results for the JSON payload.
    let mut items: Vec<ConvertItem> = Vec::with_capacity(collected.len());
    // Captures the first fatal error in single-input mode so we can
    // bubble it up as a top-level error envelope (per the
    // format-conversion spec's "single-input fatal error" scenario).
    let mut single_input_fatal: Option<SubXError> = None;

    // Process each file
    for input_path in collected.iter() {
        let fmt = output_format.to_string();
        let output_path: PathBuf = if let Some(ref o) = args.output {
            let mut p = o.clone();
            // Append per-file name when output is a directory and there are
            // multiple files (either from multiple inputs or archive expansion)
            #[allow(clippy::collapsible_if)]
            if p.is_dir()
                && (handler.paths.len() != 1 || handler.paths[0].is_dir() || collected.len() > 1)
            {
                if let Some(stem) = input_path.file_stem().and_then(|s| s.to_str()) {
                    p.push(format!("{stem}.{fmt}"));
                }
            }
            p
        } else if let Some(archive_path) = collected.archive_origin(input_path) {
            // File came from an archive: write output beside the archive
            let archive_dir = archive_path.parent().unwrap_or(Path::new("."));
            let stem = input_path
                .file_stem()
                .and_then(|s| s.to_str())
                .unwrap_or("output");
            archive_dir.join(format!("{stem}.{fmt}"))
        } else {
            input_path.with_extension(fmt.clone())
        };

        match converter.convert_file(input_path, &output_path, &fmt).await {
            Ok(result) => {
                if result.success {
                    if !json_mode {
                        println!(
                            "✓ Conversion completed: {} -> {}",
                            input_path.display(),
                            output_path.display()
                        );
                    }
                    if !args.keep_original {
                        let _ = FileManager::new().remove_file(input_path);
                    }
                    items.push(ConvertItem {
                        input: input_path.display().to_string(),
                        output: output_path.display().to_string(),
                        source_format: Some(result.input_format.to_lowercase()),
                        target_format: result.output_format.to_lowercase(),
                        encoding: args.encoding.clone(),
                        applied: true,
                        entry_count: Some(result.converted_entries),
                        status: "ok",
                        error: None,
                    });
                } else {
                    if !json_mode {
                        eprintln!("✗ Conversion failed for {}", input_path.display());
                        for err in &result.errors {
                            eprintln!("  Error: {err}");
                        }
                    }
                    let message = if result.errors.is_empty() {
                        "Conversion produced an unsuccessful result".to_string()
                    } else {
                        result.errors.join("; ")
                    };
                    items.push(ConvertItem {
                        input: input_path.display().to_string(),
                        output: output_path.display().to_string(),
                        source_format: Some(result.input_format.to_lowercase()),
                        target_format: result.output_format.to_lowercase(),
                        encoding: args.encoding.clone(),
                        applied: false,
                        entry_count: None,
                        status: "error",
                        error: Some(ConvertItemError::synthetic(
                            "subtitle_format",
                            "E_SUBTITLE_FORMAT",
                            message,
                        )),
                    });
                }
            }
            Err(e) => {
                if !json_mode {
                    eprintln!("✗ Conversion error for {}: {}", input_path.display(), e);
                }
                let item_err = ConvertItemError::from_error(&e);
                items.push(ConvertItem {
                    input: input_path.display().to_string(),
                    output: output_path.display().to_string(),
                    source_format: None,
                    target_format: fmt.clone(),
                    encoding: args.encoding.clone(),
                    applied: false,
                    entry_count: None,
                    status: "error",
                    error: Some(item_err),
                });
                if single_input && single_input_fatal.is_none() {
                    single_input_fatal = Some(e);
                }
            }
        }
    }

    // Single-input fatal: per spec's "Single-input fatal error produces
    // top-level error envelope" scenario, propagate the error so
    // `main.rs` renders the top-level error envelope and exits with the
    // matching exit code.
    if let Some(err) = single_input_fatal {
        return Err(err);
    }

    // Batch / multi-input: top-level envelope SHALL be `status == "ok"`
    // whenever the loop completed (per the "Per-File Error Isolation"
    // requirement). Per-file failures live inside `items`.
    if json_mode {
        emit_success(mode, "convert", ConvertPayload { conversions: items });
    }
    Ok(())
}

/// Execute subtitle format conversion with injected configuration service.
///
/// This function provides the new dependency injection interface for the convert command,
/// accepting a configuration service instead of loading configuration globally.
///
/// # Arguments
///
/// * `args` - Conversion arguments including input/output paths and format options
/// * `config_service` - Configuration service providing access to conversion settings
///
/// # Returns
///
/// Returns `Ok(())` on successful completion, or an error if conversion fails.
pub async fn execute_with_config(
    args: ConvertArgs,
    config_service: std::sync::Arc<dyn ConfigService>,
) -> crate::Result<()> {
    execute(args, config_service.as_ref()).await
}

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

    #[tokio::test]
    async fn test_convert_srt_to_vtt() -> crate::Result<()> {
        // Create test configuration
        let config_service = Arc::new(TestConfigService::with_defaults());

        let temp_dir = TempDir::new().unwrap();
        let input_file = temp_dir.path().join("test.srt");
        let output_file = temp_dir.path().join("test.vtt");

        fs::write(
            &input_file,
            "1\n00:00:01,000 --> 00:00:02,000\nTest subtitle\n\n",
        )
        .unwrap();

        let args = ConvertArgs {
            input: Some(input_file.clone()),
            input_paths: Vec::new(),
            recursive: false,
            format: Some(OutputSubtitleFormat::Vtt),
            output: Some(output_file.clone()),
            keep_original: false,
            encoding: String::from("utf-8"),
            no_extract: false,
        };

        execute_with_config(args, config_service).await?;

        let content = fs::read_to_string(&output_file).unwrap();
        assert!(content.contains("WEBVTT"));
        assert!(content.contains("00:00:01.000 --> 00:00:02.000"));

        Ok(())
    }

    #[tokio::test]
    async fn test_convert_batch_processing() -> crate::Result<()> {
        // Create test configuration
        let config_service = Arc::new(TestConfigService::with_defaults());

        let temp_dir = TempDir::new().unwrap();
        for i in 1..=3 {
            let file = temp_dir.path().join(format!("test{}.srt", i));
            fs::write(
                &file,
                format!(
                    "1\n00:00:0{},000 --> 00:00:0{},000\nTest {}\n\n",
                    i,
                    i + 1,
                    i
                ),
            )
            .unwrap();
        }

        let args = ConvertArgs {
            input: Some(temp_dir.path().to_path_buf()),
            input_paths: Vec::new(),
            recursive: false,
            format: Some(OutputSubtitleFormat::Vtt),
            output: Some(temp_dir.path().join("output")),
            keep_original: false,
            encoding: String::from("utf-8"),
            no_extract: false,
        };

        // Only check execution result, do not verify actual file generation,
        // as converter behavior is controlled by external modules
        execute_with_config(args, config_service).await?;

        Ok(())
    }

    #[tokio::test]
    async fn test_convert_unsupported_format() {
        // Create test configuration
        let config_service = Arc::new(TestConfigService::with_defaults());

        let temp_dir = TempDir::new().unwrap();
        let input_file = temp_dir.path().join("test.unknown");
        fs::write(&input_file, "not a subtitle").unwrap();

        let args = ConvertArgs {
            input: Some(input_file),
            input_paths: Vec::new(),
            recursive: false,
            format: Some(OutputSubtitleFormat::Srt),
            output: None,
            keep_original: false,
            encoding: String::from("utf-8"),
            no_extract: false,
        };

        let result = execute_with_config(args, config_service).await;
        // The function should succeed but individual file conversion may fail
        // This tests the overall command execution flow
        assert!(result.is_ok());
    }

    #[tokio::test]
    async fn test_convert_with_different_config() {
        // Create test configuration with custom settings
        let config = TestConfigBuilder::new()
            .with_ai_provider("test")
            .with_ai_model("test-model")
            .build_config();
        let config_service = Arc::new(TestConfigService::new(config));

        let temp_dir = TempDir::new().unwrap();
        let input_file = temp_dir.path().join("test.srt");
        let output_file = temp_dir.path().join("test.vtt");

        fs::write(
            &input_file,
            "1\n00:00:01,000 --> 00:00:02,000\nCustom test\n\n",
        )
        .unwrap();

        let args = ConvertArgs {
            input: Some(input_file.clone()),
            input_paths: Vec::new(),
            recursive: false,
            format: Some(OutputSubtitleFormat::Vtt),
            output: Some(output_file.clone()),
            keep_original: true,
            encoding: String::from("utf-8"),
            no_extract: false,
        };

        let result = execute_with_config(args, config_service).await;

        // Should work with custom configuration
        if result.is_err() {
            println!("Test with custom config failed as expected due to external dependencies");
        }
    }
}