use crate::{Template, TvaiError, TvaiResult};
use std::collections::HashMap;
use serde::{Deserialize, Serialize};

/// 音频编解码器配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudioCodec {
    pub name: String,
    #[serde(rename = "ffmpegOpts")]
    pub ffmpeg_opts: String,
    pub ext: Vec<String>,
    pub bitrate: Option<BitrateConfig>,
}

/// 比特率配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BitrateConfig {
    pub min: u32,
    #[serde(rename = "minRec")]
    pub min_rec: u32,
    pub max: u32,
    pub default: u32,
    pub suggested: Vec<u32>,
    #[serde(rename = "ffmpegOpt")]
    pub ffmpeg_opt: String,
}

/// 视频编码器配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VideoEncoder {
    pub id: String,
    pub encoder: String,
    pub profile: Option<String>,
    #[serde(rename = "allowsAlpha")]
    pub allows_alpha: u8,
    #[serde(rename = "ffmpegOpts")]
    pub ffmpeg_opts: String,
    pub ext: Vec<String>,
    pub os: Option<String>,
    #[serde(rename = "minSize")]
    pub min_size: Option<[u32; 2]>,
    #[serde(rename = "maxSize")]
    pub max_size: Option<[u32; 2]>,
    #[serde(rename = "maxBitDepth")]
    pub max_bit_depth: Option<u8>,
    #[serde(rename = "bitrateOpts")]
    pub bitrate_opts: Option<BitrateOptions>,
    #[serde(rename = "cqpValues")]
    pub cqp_values: Option<HashMap<String, Vec<u32>>>,
    pub gpu: Option<String>,
    #[serde(rename = "autoBitsPerPixel")]
    pub auto_bits_per_pixel: Option<String>,
    #[serde(rename = "maxBitRate")]
    pub max_bit_rate: Option<u32>,
    pub device: Option<String>,
    pub compute: Option<u32>,
    #[serde(rename = "isImage")]
    pub is_image: Option<bool>,
}

/// 比特率选项
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BitrateOptions {
    pub cbr: Option<String>,
    pub vbr: Option<String>,
}

/// 模型推荐规则
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModelRecommendationRule {
    pub id: String,
    pub property: String,
    #[serde(rename = "type")]
    pub rule_type: String,
    pub conditions: Vec<RecommendationCondition>,
}

/// 推荐条件
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RecommendationCondition {
    pub min: Option<u32>,
    pub max: Option<u32>,
    #[serde(rename = "recommendedModelValues")]
    pub recommended_model_values: Vec<String>,
}

/// Topaz Video AI 模板的 FFmpeg 命令生成器
#[derive(Debug, Default)]
pub struct FfmpegCommandGenerator {
    /// 从模板模型到 FFmpeg 滤镜模型的映射
    model_mappings: HashMap<String, String>,
    /// 音频编解码器配置
    audio_codecs: Vec<AudioCodec>,
    /// 视频编码器配置
    video_encoders: Vec<VideoEncoder>,
    /// 模型推荐规则
    model_recommendation_rules: Vec<ModelRecommendationRule>,
}

impl FfmpegCommandGenerator {
    /// 创建新的 FFmpeg 命令生成器
    pub fn new() -> Self {
        let mut generator = Self {
            model_mappings: HashMap::new(),
            audio_codecs: Vec::new(),
            video_encoders: Vec::new(),
            model_recommendation_rules: Vec::new(),
        };

        // 初始化默认模型映射
        generator.init_model_mappings();

        // 加载配置文件
        if let Err(e) = generator.load_configurations() {
            eprintln!("警告：加载配置文件失败: {}", e);
        }

        generator
    }

    /// 从内置配置加载编解码器和模型推荐规则
    fn load_configurations(&mut self) -> TvaiResult<()> {
        // 内置音频编解码器配置
        const AUDIO_CODECS_JSON: &str = r#"[
    {
        "name": "AAC",
        "ffmpegOpts": "aac -ac 2",
        "ext": [
            "mp4",
            "mov",
            "mkv",
            "avi"
        ],
        "bitrate": {
            "min": 32,
            "minRec": 128,
            "max": 320,
            "default": 320,
            "suggested": [
                128,
                160,
                192,
                256,
                320
            ],
            "ffmpegOpt": "-b:a <BITRATE>k"
        }
    },
    {
        "name": "AC3",
        "ffmpegOpts": "ac3",
        "ext": [
            "mp4",
            "mov",
            "mkv",
            "avi"
        ],
        "bitrate": {
            "min": 160,
            "minRec": 160,
            "max": 640,
            "default": 448,
            "suggested": [
                160,
                192,
                256,
                320,
                448,
                640
            ],
            "ffmpegOpt": "-b:a <BITRATE>k"
        }
    },
    {
        "name": "PCM",
        "ffmpegOpts": "pcm_s24le",
        "ext": [
            "mov",
            "mkv",
            "avi"
        ]
    },
    {
        "name": "Vorbis",
        "ffmpegOpts": "vorbis -ac 2",
        "ext": [
            "webm"
        ]
    }
]"#;

        // 解析音频编解码器配置
        self.audio_codecs = serde_json::from_str(AUDIO_CODECS_JSON)
            .map_err(|e| TvaiError::ConfigError(format!("解析内置音频编解码器配置失败: {}", e)))?;

        // 内置视频编码器配置（部分常用编码器）
        const VIDEO_ENCODERS_JSON: &str = r#"[
  {
    "id": "h264-high-win-nvidia",
    "encoder": "H264",
    "profile": "High",
    "allowsAlpha": 0,
    "ffmpegOpts": "-c:v h264_nvenc -profile:v high -pix_fmt yuv420p -g 30",
    "bitrateOpts": {
      "cbr": "-rc cbr -b:v <CONST_BITRATE_VALUE> -preset p6 ",
      "vbr": "-preset p7 -tune hq -rc constqp -qp <QP_VALUE> -rc-lookahead 20 -spatial_aq 1 -aq-strength 15 -b:v 0"
    },
    "cqpValues": {
      "High": [ 18 ],
      "Mid": [ 25 ],
      "Low": [ 28 ]
    },
    "ext": [
      "mov",
      "mkv",
      "mp4"
    ],
    "maxBitRate": 2000,
    "os": "windows|linux",
    "device": "nvidia|tesla",
    "minSize": [145,145],
    "maxSize": [4096,4096],
    "maxBitDepth": 8
  },
  {
    "id": "h265-main-win-nvidia",
    "encoder": "H265",
    "profile": "Main",
    "allowsAlpha": 0,
    "gpu":  "nvidia",
    "ffmpegOpts": "-c:v hevc_nvenc -profile:v main -pix_fmt yuv420p -b_ref_mode disabled -tag:v hvc1 -g 30",
    "bitrateOpts": {
      "cbr": "-rc cbr -b:v <CONST_BITRATE_VALUE> -preset p6",
      "vbr": "-preset p7 -tune hq -rc constqp -qp <QP_VALUE> -rc-lookahead 20 -spatial_aq 1 -aq-strength 15 -b:v 0"
    },
    "cqpValues": {
      "High": [ 17 ],
      "Mid": [ 25 ],
      "Low": [ 28 ]
    },
    "ext": [
      "mov",
      "mkv",
      "mp4"
    ],
    "maxBitRate": 2000,
    "os": "windows|linux",
    "device": "nvidia|tesla",
    "minSize": [129,129],
    "maxSize": [8192,4320],
    "maxBitDepth": 12
  },
  {
    "id": "h264-high-osx",
    "encoder": "H264",
    "profile": "High",
    "allowsAlpha": 0,
    "ffmpegOpts": "-c:v h264_videotoolbox -profile:v high -pix_fmt yuv420p -allow_sw 1 -g 30",
    "ext": [
      "mov",
      "mkv",
      "mp4"
    ],
    "gpu":  "appleIntel",
    "autoBitsPerPixel": "1.0",
    "maxBitRate": 2000,
    "os": "osx",
    "minSize": [2,2],
    "maxSize": [7680,4320],
    "doNotScaleFullColorRange": "always"
  },
  {
    "id": "h265-main-osx",
    "encoder": "H265",
    "profile": "Main",
    "allowsAlpha": 0,
    "ffmpegOpts": "-c:v hevc_videotoolbox -profile:v main -tag:v hvc1 -pix_fmt yuv420p -allow_sw 1 -g 30",
    "ext": [
      "mov",
      "mkv",
      "mp4"
    ],
    "gpu":  "appleIntel",
    "autoBitsPerPixel": "0.8",
    "maxBitRate": 2000,
    "os": "osx",
    "minSize": [2,2],
    "maxSize": [8192,4320],
    "doNotScaleFullColorRange": "always"
  },
  {
    "id": "h264-high-win-amd",
    "encoder": "H264",
    "profile": "High",
    "allowsAlpha": 0,
    "ffmpegOpts": "-c:v h264_amf -profile:v high -pix_fmt yuv420p -g 30",
    "gpu":  "amd",
    "bitrateOpts": {
      "cbr": "-b:v <CONST_BITRATE_VALUE>",
      "vbr": "-b:v 0 -quality 0 -rc cqp -qp_i <QPI_VALUE> -qp_p <QPP_VALUE> -qp_b <QPB_VALUE>"
    },
    "cqpValues": {
      "High": [ 19, 20, 20 ],
      "Mid": [ 20, 23, 23 ],
      "Low": [ 28, 30, 30 ]
    },
    "ext": [
      "mov",
      "mkv",
      "mp4"
    ],
    "maxBitRate": 2000,
    "os": "windows",
    "minSize": [2,2],
    "maxSize": [4096,4096],
    "device": "amd|radeon"
  },
  {
    "id": "h265-main-win-amd",
    "encoder": "H265",
    "profile": "Main",
    "allowsAlpha": 0,
    "gpu":  "amd",
    "ffmpegOpts": "-c:v hevc_amf -profile:v main -profile_tier main -tag:v hvc1 -pix_fmt yuv420p -g 30",
    "bitrateOpts": {
      "cbr": "-b:v <CONST_BITRATE_VALUE> ",
      "vbr": "-b:v 0 -quality 0 -rc cqp -qp_i <QPI_VALUE> -qp_p <QPP_VALUE>"
    },
    "cqpValues": {
      "High": [17, 19 ],
      "Mid": [20, 23 ],
      "Low": [28, 30 ]
    },
    "ext": [
      "mov",
      "mkv",
      "mp4"
    ],
    "maxBitRate": 2000,
    "os": "windows",
    "minSize": [2,2],
    "maxSize": [8192,4320],
    "device": "amd|radeon"
  },
  {
    "id": "libx264-default",
    "encoder": "H264",
    "profile": "High",
    "allowsAlpha": 0,
    "ffmpegOpts": "-c:v libx264 -profile:v high -pix_fmt yuv420p",
    "ext": [
      "mov",
      "mkv",
      "mp4",
      "avi"
    ],
    "maxBitRate": 2000,
    "os": "windows|linux|osx",
    "minSize": [1,1],
    "maxSize": [16384,16384]
  },
  {
    "id": "libx265-default",
    "encoder": "H265",
    "profile": "Main",
    "allowsAlpha": 0,
    "ffmpegOpts": "-c:v libx265 -profile:v main -pix_fmt yuv420p",
    "ext": [
      "mov",
      "mkv",
      "mp4"
    ],
    "maxBitRate": 2000,
    "os": "windows|linux|osx",
    "minSize": [1,1],
    "maxSize": [16384,16384]
  }
]"#;

        // 解析视频编码器配置
        self.video_encoders = serde_json::from_str(VIDEO_ENCODERS_JSON)
            .map_err(|e| TvaiError::ConfigError(format!("解析内置视频编码器配置失败: {}", e)))?;

        // 内置模型推荐规则
        const MODEL_RECOMMENDATION_RULES_JSON: &str = r#"[
    {
        "id": "target-resolution",
        "property": "height",
        "type":"range",
        "conditions": [
            {
                "max": 480,
                "min": 1,
                "recommendedModelValues": ["iris", "artemis"]
            },
            {
                "min": 481,
                "max": 720,
                "recommendedModelValues": ["proteus", "rhea"]
            },
            {
                "min": 721,
                "max": 1080,
                "recommendedModelValues": ["proteus", "nyx", "rhea"]
            },
            {
                "min": 1081,
                "recommendedModelValues": ["nyx", "theia", "proteus"]
            }
        ]
    }
]"#;

        // 解析模型推荐规则
        self.model_recommendation_rules = serde_json::from_str(MODEL_RECOMMENDATION_RULES_JSON)
            .map_err(|e| TvaiError::ConfigError(format!("解析内置模型推荐规则失败: {}", e)))?;

        Ok(())
    }

    /// 初始化从模板模型到 FFmpeg 滤镜模型的映射
    fn init_model_mappings(&mut self) {
        // 增强模型 - Proteus 系列（通用）
        self.model_mappings.insert("prob-3".to_string(), "ahq-12".to_string());
        self.model_mappings.insert("prob-4".to_string(), "ahq-12".to_string());

        // 增强模型 - 专用系列
        self.model_mappings.insert("nyx-3".to_string(), "nyx-3".to_string()); // Iris 系列（低光/噪声）
        self.model_mappings.insert("hyp-1".to_string(), "hyp-1".to_string()); // Hyperion HDR 模型

        // Artemis 系列（动画/卡通）
        self.model_mappings.insert("art-1".to_string(), "art-1".to_string());
        self.model_mappings.insert("art-2".to_string(), "art-2".to_string());
        self.model_mappings.insert("alq-13".to_string(), "ahq-12".to_string()); // Artemis 基准模型

        // Gaia 系列（自然场景）
        self.model_mappings.insert("gai-1".to_string(), "gai-1".to_string());
        self.model_mappings.insert("gai-2".to_string(), "gai-2".to_string());
        self.model_mappings.insert("ghq-5".to_string(), "ahq-12".to_string()); // Gaia 基准模型

        // Theia 系列（细节恢复）
        self.model_mappings.insert("the-1".to_string(), "the-1".to_string());
        self.model_mappings.insert("the-2".to_string(), "the-2".to_string());

        // Iris 系列（低光/噪声）
        self.model_mappings.insert("iris-1".to_string(), "nyx-3".to_string());
        self.model_mappings.insert("iris-2".to_string(), "nyx-3".to_string());
        self.model_mappings.insert("iris-3".to_string(), "nyx-3".to_string()); // Iris 基准模型

        // Nyx 系列（降噪）
        self.model_mappings.insert("nyx-1".to_string(), "nyx-3".to_string());
        self.model_mappings.insert("nyx-2".to_string(), "nyx-3".to_string()); // Nyx 基准模型
        self.model_mappings.insert("nxf-1".to_string(), "nyx-3".to_string()); // Nyx Fast 基准模型

        // 专用模型
        self.model_mappings.insert("rhea-1".to_string(), "ahq-12".to_string()); // Rhea 基准模型
        self.model_mappings.insert("rxl-1".to_string(), "ahq-12".to_string()); // RXL 基准模型

        // 帧插值模型
        self.model_mappings.insert("apo-8".to_string(), "chr-2".to_string()); // Apollo
        self.model_mappings.insert("apf-1".to_string(), "chr-2".to_string()); // Apollo Fast
        self.model_mappings.insert("chr-2".to_string(), "chr-2".to_string()); // Chronos
        self.model_mappings.insert("chf-3".to_string(), "chr-2".to_string()); // Chronos Fast
        self.model_mappings.insert("aion-1".to_string(), "chr-2".to_string()); // Aion (16X)

        // 运动模糊模型
        self.model_mappings.insert("thm-2".to_string(), "thm-2".to_string());

        // 稳定化模型（映射到 ref-2 用于 tvai_stb）
        // 注意：模板稳定化使用与 tvai_stb 滤镜不同的方法
    }

    /// 添加自定义模型映射
    pub fn add_model_mapping(&mut self, template_model: String, ffmpeg_model: String) {
        self.model_mappings.insert(template_model, ffmpeg_model);
    }

    /// 从模板生成 FFmpeg 命令
    pub fn generate(&self, template: &Template, input_file: &str, output_file: &str) -> TvaiResult<String> {
        let mut filters = Vec::new();
        let settings = &template.settings;

        // 生成增强滤镜（通常是链中的第一个）
        if settings.enhance.active {
            let up_filter = self.generate_enhancement_filter(&settings.enhance)?;
            filters.push(up_filter);
        }

        // 生成帧插值滤镜（在增强之后）
        if settings.slow_motion.active {
            let fi_filter = self.generate_frame_interpolation_filter(&settings.slow_motion, &settings.output)?;
            filters.push(fi_filter);
        }

        // 生成稳定化滤镜（在插值之后）
        if settings.stabilize.active {
            let stb_filter = self.generate_stabilization_filter(&settings.stabilize)?;
            filters.push(stb_filter);
        }

        // 生成运动模糊滤镜（如果激活）
        if settings.motion_blur.active {
            let mb_filter = self.generate_motion_blur_filter(&settings.motion_blur)?;
            filters.push(mb_filter);
        }

        // 生成颗粒滤镜（通常是链中的最后一个）
        if settings.grain.active {
            let grain_filter = self.generate_grain_filter(&settings.grain)?;
            filters.push(grain_filter);
        }

        // 如果存在滤镜管理器，处理第二次增强
        if let Some(ref filter_manager) = settings.filter_manager {
            if filter_manager.second_enhancement_enabled && settings.enhance.active {
                let second_enhance_filter = self.generate_second_enhancement_filter(&settings.enhance, filter_manager)?;
                filters.push(second_enhance_filter);
            }
        }

        // 构建完整的 FFmpeg 命令
        let mut command = format!("ffmpeg -i \"{}\"", input_file);

        if !filters.is_empty() {
            command.push_str(" -vf \"");
            command.push_str(&filters.join(","));
            command.push('"');
        }

        // 添加输出设置
        command.push_str(&self.generate_output_settings(&settings.output)?);

        command.push_str(&format!(" \"{}\"", output_file));

        Ok(command)
    }

    /// 生成稳定化滤镜 (tvai_stb)
    fn generate_stabilization_filter(&self, settings: &crate::StabilizeSettings) -> TvaiResult<String> {
        let mut params = Vec::new();

        // 使用默认的稳定化模型
        params.push("model=ref-2".to_string());

        // 映射稳定化方法（0: 自动裁剪, 1: 全帧稳定化）
        let full_frame = if settings.method == 0 { 0 } else { 1 };
        params.push(format!("full={}", full_frame));

        // 映射平滑度（模板中为 0-100，转换为 0-16 范围）
        let smoothness = (settings.smooth as f64 / 100.0 * 16.0).min(16.0);
        params.push(format!("smoothness={:.1}", smoothness));

        // 滚动快门校正
        if settings.rsc {
            params.push("roll=1".to_string());
        }

        // 减少运动抖动
        if settings.reduce_motion {
            let reduce_level = settings.reduce_motion_iteration.min(5);
            params.push(format!("reduce={}", reduce_level));
        }

        // 调试信息
        println!("生成 tvai_stb 滤镜参数: {:?}", params);
        println!("稳定化设置: smoothness={:.1}, full={}, roll={}, reduce={}",
                 smoothness, full_frame, settings.rsc,
                 if settings.reduce_motion { settings.reduce_motion_iteration } else { 0 });

        Ok(format!("tvai_stb={}", params.join(":")))
    }

    /// 生成增强滤镜 (tvai_up)
    fn generate_enhancement_filter(&self, settings: &crate::EnhanceSettings) -> TvaiResult<String> {
        let mut params = Vec::new();

        // 映射模型
        let model = self.model_mappings.get(&settings.model)
            .ok_or_else(|| TvaiError::ModelMappingError(format!("未知的增强模型: {}", settings.model)))?;
        params.push(format!("model={}", model));

        // 添加缩放参数（默认不缩放，除非指定）
        params.push("scale=0".to_string());

        // 将增强参数映射到 tvai_up 参数（使用标准化值 0.0-1.0）
        if settings.compress != 0 {
            let compression = settings.compress as f64 / 100.0;
            params.push(format!("compression={:.2}", compression));
        }

        if settings.detail != 0 {
            let details = settings.detail as f64 / 100.0;
            params.push(format!("details={:.2}", details));
        }

        if settings.denoise != 0 {
            let noise = settings.denoise as f64 / 100.0;
            params.push(format!("noise={:.2}", noise));
        }

        if settings.dehalo != 0 {
            let halo = settings.dehalo as f64 / 100.0;
            params.push(format!("halo={:.2}", halo));
        }

        if settings.deblur != 0 {
            let blur = settings.deblur as f64 / 100.0;
            params.push(format!("blur={:.2}", blur));
        }

        if settings.sharpen != 0 {
            let preblur = -(settings.sharpen as f64 / 100.0);
            params.push(format!("preblur={:.2}", preblur));
        }

        // 如果不是逐行扫描，添加视频类型参数
        if settings.video_type != 1 {
            match settings.video_type {
                0 => params.push("interlaced=1".to_string()),
                2 => params.push("telecine=1".to_string()),
                _ => {}
            }
        }

        // 如果指定了场序，添加场序参数
        if settings.field_order != 0 {
            match settings.field_order {
                1 => params.push("field_order=tff".to_string()),
                2 => params.push("field_order=bff".to_string()),
                _ => {}
            }
        }

        // 如果指定了自动增强级别，添加参数
        if settings.auto != 0 {
            let auto_level = settings.auto as f64 / 100.0;
            params.push(format!("auto={:.2}", auto_level));
        }

        // 如果指定了添加噪声参数，添加参数
        if settings.add_noise != 0 {
            let add_noise = settings.add_noise as f64 / 100.0;
            params.push(format!("add_noise={:.2}", add_noise));
        }

        // 如果不是默认值，添加恢复原始细节参数
        if settings.recover_original_detail_value != 20 {
            let recover = settings.recover_original_detail_value as f64 / 100.0;
            params.push(format!("recover_detail={:.2}", recover));
        }

        // 基于 AI 引擎标志添加模型特定优化
        if settings.is_artemis {
            // Artemis 动画/卡通内容优化
            params.push("content_type=animation".to_string());
            params.push("edge_enhance=1".to_string());
        } else if settings.is_gaia {
            // Gaia 自然场景优化
            params.push("content_type=natural".to_string());
            params.push("texture_enhance=1".to_string());
        } else if settings.is_theia {
            // Theia 细节恢复优化
            params.push("detail_mode=high".to_string());
            params.push("sharpening_boost=1".to_string());
        } else if settings.is_iris {
            // Iris 低光/噪声优化
            params.push("noise_profile=aggressive".to_string());
            params.push("low_light_boost=1".to_string());
        } else if settings.is_proteus {
            // Proteus 是默认的通用模型
            params.push("content_type=general".to_string());
        }

        // 如果指定了焦点修复级别，添加参数
        if let Some(ref focus_level) = settings.focus_fix_level {
            if focus_level != "Off" {
                let focus_value = match focus_level.as_str() {
                    "Low" => 0.25,
                    "Medium" => 0.5,
                    "High" => 0.75,
                    "Maximum" => 1.0,
                    _ => 0.0,
                };
                if focus_value > 0.0 {
                    params.push(format!("focus_fix={:.2}", focus_value));
                }
            }
        }

        Ok(format!("tvai_up={}", params.join(":")))
    }

    /// 生成帧插值滤镜 (tvai_fi)
    fn generate_frame_interpolation_filter(&self, slowmo_settings: &crate::SlowMotionSettings, output_settings: &crate::OutputSettings) -> TvaiResult<String> {
        let mut params = Vec::new();

        // 映射模型
        let model = self.model_mappings.get(&slowmo_settings.model)
            .ok_or_else(|| TvaiError::ModelMappingError(format!("未知的帧插值模型: {}", slowmo_settings.model)))?;
        params.push(format!("model={}", model));

        // 设置慢动作因子
        if slowmo_settings.factor != 1.0 {
            params.push(format!("slowmo={}", slowmo_settings.factor));
        }

        // 设置输出帧率（video_rate 格式）
        if output_settings.out_fps > 0.0 {
            // 将浮点数转换为分数格式，例如 60.0 -> "60/1"
            if output_settings.out_fps.fract() == 0.0 {
                params.push(format!("fps={}/1", output_settings.out_fps as i32));
            } else {
                // 对于非整数帧率，使用更精确的分数表示
                params.push(format!("fps={:.3}", output_settings.out_fps));
            }
        }
        // 注意：当 out_fps 为 0 时，不添加 fps 参数，让 tvai_fi 使用默认的 "0" 值

        // 重复帧阈值（rdt 参数）
        if !slowmo_settings.duplicate {
            params.push("rdt=-0.01".to_string()); // 禁用重复帧移除
        } else if slowmo_settings.duplicate_threshold != 10 { // 仅在非默认值时添加
            let threshold = slowmo_settings.duplicate_threshold as f64 / 1000.0;
            params.push(format!("rdt={:.3}", threshold));
        }

        // 调试信息
        println!("生成 tvai_fi 滤镜参数: {:?}", params);
        println!("输出 FPS: {}, 慢动作因子: {}", output_settings.out_fps, slowmo_settings.factor);

        Ok(format!("tvai_fi={}", params.join(":")))
    }

    /// 生成运动模糊滤镜 (tvai_mb)
    fn generate_motion_blur_filter(&self, settings: &crate::MotionBlurSettings) -> TvaiResult<String> {
        let mut params = Vec::new();

        // 映射模型
        let model = self.model_mappings.get(&settings.model)
            .ok_or_else(|| TvaiError::ModelMappingError(format!("未知的运动模糊模型: {}", settings.model)))?;
        params.push(format!("model={}", model));

        Ok(format!("tvai_mb={}", params.join(":")))
    }

    /// 生成颗粒滤镜 (tvai_grain 或噪声近似)
    fn generate_grain_filter(&self, settings: &crate::GrainSettings) -> TvaiResult<String> {
        // 尝试使用 tvai_grain，如果不可用则回退到噪声滤镜
        let mut params = Vec::new();

        // 颗粒量（0-100 比例）
        let amount = settings.grain as f64 / 100.0;
        params.push(format!("amount={:.2}", amount));

        // 颗粒大小（1-10 比例）
        params.push(format!("size={}", settings.grain_size));

        // 使用 tvai_grain 滤镜
        Ok(format!("tvai_grain={}", params.join(":")))
    }

    /// 生成第二次增强滤镜
    fn generate_second_enhancement_filter(&self, enhance_settings: &crate::EnhanceSettings, filter_manager: &crate::FilterManagerSettings) -> TvaiResult<String> {
        let mut params = Vec::new();

        // 使用与主要增强相同的模型
        let model = self.model_mappings.get(&enhance_settings.model)
            .ok_or_else(|| TvaiError::ModelMappingError(format!("未知的增强模型: {}", enhance_settings.model)))?;
        params.push(format!("model={}", model));

        // 设置中间分辨率缩放
        let intermediate_scale = match filter_manager.second_enhancement_intermediate_resolution {
            0 => 0.5,  // 半分辨率
            1 => 0.75, // 3/4 分辨率
            2 => 1.0,  // 相同分辨率
            3 => 1.5,  // 1.5x 分辨率
            4 => 2.0,  // 2x 分辨率
            _ => 1.0,  // 默认为相同分辨率
        };
        params.push(format!("scale={}", intermediate_scale));

        // 为第二次处理应用较轻的增强参数
        if enhance_settings.denoise != 0 {
            let noise = (enhance_settings.denoise as f64 / 100.0) * 0.5; // 减半
            params.push(format!("noise={:.2}", noise));
        }

        if enhance_settings.detail != 0 {
            let details = (enhance_settings.detail as f64 / 100.0) * 0.5; // 减半
            params.push(format!("details={:.2}", details));
        }

        Ok(format!("tvai_up={}", params.join(":")))
    }

    /// 根据编解码器名称获取音频编解码器配置
    pub fn get_audio_codec(&self, name: &str) -> Option<&AudioCodec> {
        self.audio_codecs.iter().find(|codec| codec.name.eq_ignore_ascii_case(name))
    }

    /// 根据编码器ID获取视频编码器配置
    pub fn get_video_encoder(&self, id: &str) -> Option<&VideoEncoder> {
        self.video_encoders.iter().find(|encoder| encoder.id == id)
    }

    /// 根据编码器名称获取视频编码器配置
    pub fn get_video_encoder_by_name(&self, name: &str) -> Option<&VideoEncoder> {
        self.video_encoders.iter().find(|encoder| encoder.encoder.eq_ignore_ascii_case(name))
    }

    /// 根据分辨率推荐模型
    pub fn recommend_model_for_resolution(&self, height: u32) -> Vec<String> {
        for rule in &self.model_recommendation_rules {
            if rule.id == "target-resolution" && rule.property == "height" {
                for condition in &rule.conditions {
                    let min = condition.min.unwrap_or(0);
                    let max = condition.max.unwrap_or(u32::MAX);
                    if height >= min && height <= max {
                        return condition.recommended_model_values.clone();
                    }
                }
            }
        }
        vec!["prob-4".to_string()] // 默认推荐 Proteus
    }

    /// 使用配置文件生成音频编解码器参数
    pub fn generate_audio_codec_params(&self, codec_name: &str, bitrate: Option<u32>) -> String {
        if let Some(codec) = self.get_audio_codec(codec_name) {
            let mut params = format!("-c:a {}", codec.ffmpeg_opts);

            if let (Some(bitrate_config), Some(bitrate_value)) = (&codec.bitrate, bitrate) {
                let bitrate_param = bitrate_config.ffmpeg_opt.replace("<BITRATE>", &bitrate_value.to_string());
                params.push_str(&format!(" {}", bitrate_param));
            }

            params
        } else {
            // 回退到默认设置
            if let Some(bitrate) = bitrate {
                format!("-c:a {} -b:a {}k", codec_name, bitrate)
            } else {
                format!("-c:a {}", codec_name)
            }
        }
    }

    /// 使用配置文件生成视频编码器参数
    pub fn generate_video_encoder_params(&self, encoder_id: &str, quality_mode: &str, quality_value: Option<u32>) -> String {
        if let Some(encoder) = self.get_video_encoder(encoder_id) {
            let mut params = encoder.ffmpeg_opts.clone();

            // 添加质量设置
            if let (Some(bitrate_opts), Some(quality)) = (&encoder.bitrate_opts, quality_value) {
                match quality_mode {
                    "cbr" => {
                        if let Some(cbr_template) = &bitrate_opts.cbr {
                            let cbr_param = cbr_template.replace("<CONST_BITRATE_VALUE>", &format!("{}k", quality));
                            params.push_str(&format!(" {}", cbr_param));
                        }
                    },
                    "vbr" | "cqp" => {
                        if let Some(vbr_template) = &bitrate_opts.vbr {
                            let mut vbr_param = vbr_template.clone();

                            // 处理不同的质量参数占位符
                            if let Some(cqp_values) = &encoder.cqp_values {
                                if let Some(values) = cqp_values.get("Mid") { // 默认使用中等质量
                                    for (i, value) in values.iter().enumerate() {
                                        match i {
                                            0 => vbr_param = vbr_param.replace("<QP_VALUE>", &value.to_string())
                                                                     .replace("<QPI_VALUE>", &value.to_string()),
                                            1 => vbr_param = vbr_param.replace("<QPP_VALUE>", &value.to_string()),
                                            2 => vbr_param = vbr_param.replace("<QPB_VALUE>", &value.to_string()),
                                            _ => break,
                                        }
                                    }
                                }
                            }

                            // 如果没有预设值，使用传入的质量值
                            vbr_param = vbr_param.replace("<QV_VALUE>", &quality.to_string());
                            params.push_str(&format!(" {}", vbr_param));
                        }
                    },
                    _ => {}
                }
            }

            params
        } else {
            // 回退到默认设置
            format!("-c:v {}", encoder_id)
        }
    }

    /// 生成输出设置
    fn generate_output_settings(&self, settings: &crate::OutputSettings) -> TvaiResult<String> {
        let mut output_params = Vec::new();

        // 检查输出设置是否激活
        if !settings.active {
            // 如果输出设置未激活，使用配置文件中的默认设置
            let audio_params = self.generate_audio_codec_params("AAC", Some(128));
            output_params.push("-c:v libx264".to_string());
            output_params.push(audio_params);
            return Ok(format!(" {}", output_params.join(" ")));
        }

        // 硬件加速
        if let Some(ref hwaccel) = settings.hwaccel {
            output_params.push(format!("-hwaccel {}", hwaccel));
        }

        // 基于优先级设置处理分辨率
        let use_custom_resolution = if let (Some(_width), Some(_height)) = (settings.width, settings.height) {
            // 检查自定义分辨率优先级
            let priority = settings.custom_resolution_priority.unwrap_or(0);
            match priority {
                0 => true,  // 自定义分辨率具有正常优先级
                1 => true,  // 自定义分辨率具有高优先级
                2 => false, // 尺寸方法优先于自定义分辨率
                _ => true,  // 默认使用自定义分辨率
            }
        } else {
            false
        };

        if use_custom_resolution {
            let width = settings.width.unwrap();
            let height = settings.height.unwrap();

            // 处理宽高比锁定
            if settings.lock_aspect_ratio.unwrap_or(true) {
                // 使用缩放滤镜保持宽高比
                output_params.push(format!("-vf scale={}:{}:force_original_aspect_ratio=decrease", width, height));

                // 如果需要，添加填充以达到精确尺寸
                if settings.crop_to_fit {
                    // 裁剪以适应精确尺寸
                    output_params.push(format!("-vf scale={}:{}:force_original_aspect_ratio=increase,crop={}:{}", width, height, width, height));
                } else {
                    // 填充以适应精确尺寸
                    output_params.push(format!("-vf scale={}:{}:force_original_aspect_ratio=decrease,pad={}:{}:(ow-iw)/2:(oh-ih)/2", width, height, width, height));
                }
            } else {
                // 拉伸到精确尺寸（忽略宽高比）
                output_params.push(format!("-s {}x{}", width, height));
            }
        } else {
            // 处理输出尺寸方法（基于 Topaz Video AI 尺寸方法）
            match settings.out_size_method {
                0 => {
                    // 原始尺寸 - 不缩放
                },
                1 => {
                    // SD (480p)
                    output_params.push("-s 720x480".to_string());
                },
                2 => {
                    // DVD (576p)
                    output_params.push("-s 720x576".to_string());
                },
                3 => {
                    // HD Ready (720p)
                    output_params.push("-s 1280x720".to_string());
                },
                4 => {
                    // HD (1080p)
                    output_params.push("-s 1920x1080".to_string());
                },
                5 => {
                    // QHD (1440p)
                    output_params.push("-s 2560x1440".to_string());
                },
                6 => {
                    // FHD (1920x1080) - 与 4 相同
                    output_params.push("-s 1920x1080".to_string());
                },
                7 => {
                    // 4K UHD (2160p)
                    output_params.push("-s 3840x2160".to_string());
                },
                8 => {
                    // 8K UHD (4320p)
                    output_params.push("-s 7680x4320".to_string());
                },
                _ => {
                    // 未知方法 - 保持原始尺寸
                }
            }
        }

        // 为尺寸方法输出处理裁剪适应
        if settings.crop_to_fit && !use_custom_resolution {
            // 为尺寸方法输出应用裁剪适应
            if let Some(last_param) = output_params.last_mut() {
                if last_param.starts_with("-s ") {
                    let size = &last_param[3..];
                    // 用缩放+裁剪替换简单缩放
                    *last_param = format!("-vf scale={}:force_original_aspect_ratio=increase,crop={}", size, size);
                }
            }
        }

        // 处理像素宽高比
        if settings.output_par != 0 {
            match settings.output_par {
                1 => output_params.push("-aspect 4:3".to_string()),
                2 => output_params.push("-aspect 16:9".to_string()),
                3 => output_params.push("-aspect 1:1".to_string()),
                _ => {}
            }
        }

        // 帧率
        if settings.out_fps > 0.0 {
            output_params.push(format!("-r {}", settings.out_fps));
        }

        // 视频编解码器 - 使用配置文件
        if let Some(ref codec) = settings.codec {
            // 尝试从配置文件中查找编码器
            if let Some(encoder) = self.get_video_encoder_by_name(codec) {
                let quality_mode = if settings.bitrate.is_some() { "cbr" } else { "vbr" };
                let quality_value = settings.bitrate.map(|b| b as u32).or(settings.crf.map(|c| c as u32));
                let encoder_params = self.generate_video_encoder_params(&encoder.id, quality_mode, quality_value);
                output_params.push(encoder_params);
            } else {
                // 回退到传统方式
                output_params.push(format!("-c:v {}", codec));

                // 视频质量设置
                if let Some(bitrate) = settings.bitrate {
                    output_params.push(format!("-b:v {}k", bitrate));
                } else if let Some(crf) = settings.crf {
                    // 使用 CRF 进行基于质量的编码
                    match codec.as_str() {
                        "hevc_nvenc" | "h264_nvenc" => {
                            output_params.push(format!("-cq {}", crf));
                        },
                        "h264_amf" | "hevc_amf" => {
                            output_params.push(format!("-qp {}", crf));
                        },
                        "h264_qsv" | "hevc_qsv" => {
                            output_params.push(format!("-global_quality {}", crf));
                        },
                        _ => {
                            output_params.push(format!("-crf {}", crf));
                        }
                    }
                } else {
                    output_params.push("-crf 23".to_string()); // 默认质量
                }
            }
        } else {
            // 使用默认的 H.264 编码器
            output_params.push("-c:v libx264".to_string());
            output_params.push("-crf 23".to_string());
        }

        // 编码预设
        if let Some(ref preset) = settings.preset {
            output_params.push(format!("-preset {}", preset));
        } else {
            output_params.push("-preset medium".to_string());
        }

        // 视频配置文件
        if let Some(ref profile) = settings.profile {
            output_params.push(format!("-profile:v {}", profile));
        }

        // 视频级别
        if let Some(ref level) = settings.level {
            output_params.push(format!("-level {}", level));
        }

        // GOP 大小
        if let Some(gop_size) = settings.gop_size {
            output_params.push(format!("-g {}", gop_size));
        }

        // B 帧
        if let Some(b_frames) = settings.b_frames {
            output_params.push(format!("-bf {}", b_frames));
        }

        // 像素格式
        if let Some(ref pix_fmt) = settings.pixel_format {
            output_params.push(format!("-pix_fmt {}", pix_fmt));
        }

        // 颜色设置
        if let Some(ref colorspace) = settings.colorspace {
            output_params.push(format!("-colorspace {}", colorspace));
        }
        if let Some(ref color_primaries) = settings.color_primaries {
            output_params.push(format!("-color_primaries {}", color_primaries));
        }
        if let Some(ref color_trc) = settings.color_trc {
            output_params.push(format!("-color_trc {}", color_trc));
        }

        // 音频设置 - 使用配置文件
        if let Some(ref audio_codec) = settings.audio_codec {
            if audio_codec != "copy" {
                // 使用配置文件生成音频编解码器参数
                let audio_params = self.generate_audio_codec_params(audio_codec, settings.audio_bitrate.map(|b| b as u32));
                output_params.push(audio_params);

                // 添加额外的音频参数
                if let Some(audio_sample_rate) = settings.audio_sample_rate {
                    output_params.push(format!("-ar {}", audio_sample_rate));
                }

                if let Some(audio_channels) = settings.audio_channels {
                    output_params.push(format!("-ac {}", audio_channels));
                }
            } else {
                output_params.push("-c:a copy".to_string());
            }
        } else {
            // 使用默认音频编解码器
            let default_audio = self.generate_audio_codec_params("AAC", Some(128));
            output_params.push(default_audio);
        }

        // 自定义参数
        if let Some(ref custom_params) = settings.custom_params {
            for param in custom_params {
                output_params.push(param.clone());
            }
        }

        if output_params.is_empty() {
            Ok(String::new())
        } else {
            Ok(format!(" {}", output_params.join(" ")))
        }
    }

    /// 获取可用的模型映射
    pub fn get_model_mappings(&self) -> &HashMap<String, String> {
        &self.model_mappings
    }

    /// 验证模板用于 FFmpeg 生成
    pub fn validate_template(&self, template: &Template) -> TvaiResult<()> {
        let settings = &template.settings;

        // 检查是否启用了任何处理模块
        if !settings.enhance.active && !settings.slow_motion.active && !settings.stabilize.active && !settings.grain.active {
            return Err(TvaiError::ValidationError("没有激活的处理模块".to_string()));
        }

        // 如果激活，验证增强模型
        if settings.enhance.active && !self.model_mappings.contains_key(&settings.enhance.model) {
            return Err(TvaiError::ModelMappingError(format!("未知的增强模型: {}", settings.enhance.model)));
        }

        // 如果激活，验证帧插值模型
        if settings.slow_motion.active && !self.model_mappings.contains_key(&settings.slow_motion.model) {
            return Err(TvaiError::ModelMappingError(format!("未知的帧插值模型: {}", settings.slow_motion.model)));
        }

        Ok(())
    }

    /// 生成带硬件加速的高级 FFmpeg 命令
    pub fn generate_with_hardware_acceleration(&self, template: &Template, input_file: &str, output_file: &str, gpu_device: Option<&str>) -> TvaiResult<String> {
        let mut command = self.generate(template, input_file, output_file)?;

        // 为 TVAI 滤镜添加 GPU 设备规范
        if let Some(device) = gpu_device {
            command = command.replace("tvai_up=", &format!("tvai_up=device={}:", device));
            command = command.replace("tvai_fi=", &format!("tvai_fi=device={}:", device));
            command = command.replace("tvai_stb=", &format!("tvai_stb=device={}:", device));
        }

        Ok(command)
    }

    /// 生成带自定义输出编解码器的命令
    pub fn generate_with_codec(&self, template: &Template, input_file: &str, output_file: &str, codec: &str, quality: Option<i32>) -> TvaiResult<String> {
        // 创建带自定义编解码器设置的修改模板
        let mut modified_template = template.clone();
        modified_template.settings.output.codec = Some(codec.to_string());

        if let Some(q) = quality {
            // 设置质量时清除比特率
            modified_template.settings.output.bitrate = None;
            modified_template.settings.output.crf = Some(q);
        }

        // 使用修改的模板生成命令
        self.generate(&modified_template, input_file, output_file)
    }

    /// 生成批处理命令
    pub fn generate_batch_commands(&self, template: &Template, input_files: &[String], output_dir: &str) -> TvaiResult<Vec<String>> {
        let mut commands = Vec::new();

        for input_file in input_files {
            let input_path = std::path::Path::new(input_file);
            let filename = input_path.file_stem()
                .ok_or_else(|| TvaiError::FfmpegError("无效的输入文件名".to_string()))?
                .to_string_lossy();

            let output_file = format!("{}/{}_processed.mp4", output_dir, filename);
            let command = self.generate(template, input_file, &output_file)?;
            commands.push(command);
        }

        Ok(commands)
    }

    /// 获取所有可用的音频编解码器
    pub fn get_available_audio_codecs(&self) -> &Vec<AudioCodec> {
        &self.audio_codecs
    }

    /// 获取所有可用的视频编码器
    pub fn get_available_video_encoders(&self) -> &Vec<VideoEncoder> {
        &self.video_encoders
    }

    /// 根据操作系统和GPU类型筛选视频编码器
    pub fn get_compatible_video_encoders(&self, os: &str, gpu: Option<&str>) -> Vec<&VideoEncoder> {
        self.video_encoders.iter().filter(|encoder| {
            // 检查操作系统兼容性
            let os_compatible = encoder.os.as_ref().map_or(true, |encoder_os| {
                encoder_os.split('|').any(|supported_os| supported_os == os)
            });

            // 检查GPU兼容性
            let gpu_compatible = if let Some(gpu_type) = gpu {
                encoder.gpu.as_ref().map_or(true, |encoder_gpu| encoder_gpu == gpu_type)
            } else {
                encoder.gpu.is_none() // 如果没有指定GPU，只返回不需要GPU的编码器
            };

            os_compatible && gpu_compatible
        }).collect()
    }

    /// 根据文件扩展名获取兼容的编码器
    pub fn get_encoders_for_extension(&self, extension: &str) -> Vec<&VideoEncoder> {
        self.video_encoders.iter().filter(|encoder| {
            encoder.ext.iter().any(|ext| ext.eq_ignore_ascii_case(extension))
        }).collect()
    }

    /// 生成带有自动编码器选择的命令
    pub fn generate_with_auto_encoder(&self, template: &Template, input_file: &str, output_file: &str, target_os: &str, gpu: Option<&str>) -> TvaiResult<String> {
        // 从输出文件获取扩展名
        let output_path = std::path::Path::new(output_file);
        let extension = output_path.extension()
            .and_then(|ext| ext.to_str())
            .unwrap_or("mp4");

        // 获取兼容的编码器
        let compatible_encoders = self.get_compatible_video_encoders(target_os, gpu);
        let suitable_encoders: Vec<_> = compatible_encoders.into_iter()
            .filter(|encoder| encoder.ext.iter().any(|ext| ext.eq_ignore_ascii_case(extension)))
            .collect();

        if suitable_encoders.is_empty() {
            return Err(TvaiError::FfmpegError(format!("没有找到适用于 {} 格式和 {} 操作系统的编码器", extension, target_os)));
        }

        // 选择第一个合适的编码器
        let selected_encoder = suitable_encoders[0];

        // 创建修改的模板
        let mut modified_template = template.clone();
        modified_template.settings.output.codec = Some(selected_encoder.encoder.clone());

        // 生成命令
        self.generate(&modified_template, input_file, output_file)
    }

    /// 生成编码器信息报告
    pub fn generate_encoder_report(&self) -> String {
        let mut report = String::new();
        report.push_str("=== 可用编码器报告 ===\n\n");

        // 按编码器类型分组
        let mut h264_encoders = Vec::new();
        let mut h265_encoders = Vec::new();
        let mut av1_encoders = Vec::new();
        let mut other_encoders = Vec::new();

        for encoder in &self.video_encoders {
            match encoder.encoder.as_str() {
                "H264" => h264_encoders.push(encoder),
                "H265" => h265_encoders.push(encoder),
                "AV1" => av1_encoders.push(encoder),
                _ => other_encoders.push(encoder),
            }
        }

        // 生成各类型编码器的报告
        if !h264_encoders.is_empty() {
            report.push_str("## H.264 编码器\n");
            for encoder in h264_encoders {
                report.push_str(&format!("- {} ({}): {}\n", encoder.id, encoder.profile.as_deref().unwrap_or("默认"), encoder.ffmpeg_opts));
            }
            report.push('\n');
        }

        if !h265_encoders.is_empty() {
            report.push_str("## H.265 编码器\n");
            for encoder in h265_encoders {
                report.push_str(&format!("- {} ({}): {}\n", encoder.id, encoder.profile.as_deref().unwrap_or("默认"), encoder.ffmpeg_opts));
            }
            report.push('\n');
        }

        if !av1_encoders.is_empty() {
            report.push_str("## AV1 编码器\n");
            for encoder in av1_encoders {
                report.push_str(&format!("- {} ({}): {}\n", encoder.id, encoder.profile.as_deref().unwrap_or("默认"), encoder.ffmpeg_opts));
            }
            report.push('\n');
        }

        if !other_encoders.is_empty() {
            report.push_str("## 其他编码器\n");
            for encoder in other_encoders {
                report.push_str(&format!("- {} {}: {}\n", encoder.encoder, encoder.id, encoder.ffmpeg_opts));
            }
            report.push('\n');
        }

        // 音频编解码器报告
        report.push_str("## 音频编解码器\n");
        for codec in &self.audio_codecs {
            report.push_str(&format!("- {}: {}\n", codec.name, codec.ffmpeg_opts));
        }

        report
    }
}

/// 用于更复杂场景的 FFmpeg 命令构建器
#[derive(Debug, Default)]
pub struct FfmpegCommandBuilder {
    input_file: String,
    output_file: String,
    filters: Vec<String>,
    codec: String,
    quality: Option<i32>,
    hardware_accel: Option<String>,
    custom_params: Vec<String>,
}

impl FfmpegCommandBuilder {
    /// 创建新的命令构建器
    pub fn new(input_file: &str, output_file: &str) -> Self {
        Self {
            input_file: input_file.to_string(),
            output_file: output_file.to_string(),
            filters: Vec::new(),
            codec: "libx264".to_string(),
            quality: Some(18),
            hardware_accel: None,
            custom_params: Vec::new(),
        }
    }

    /// 添加滤镜
    pub fn add_filter(mut self, filter: &str) -> Self {
        self.filters.push(filter.to_string());
        self
    }

    /// 设置编解码器
    pub fn codec(mut self, codec: &str) -> Self {
        self.codec = codec.to_string();
        self
    }

    /// 设置质量
    pub fn quality(mut self, quality: i32) -> Self {
        self.quality = Some(quality);
        self
    }

    /// 设置硬件加速
    pub fn hardware_accel(mut self, accel: &str) -> Self {
        self.hardware_accel = Some(accel.to_string());
        self
    }

    /// 添加自定义参数
    pub fn custom_param(mut self, param: &str) -> Self {
        self.custom_params.push(param.to_string());
        self
    }

    /// 构建命令
    pub fn build(self) -> String {
        let mut command = format!("ffmpeg -i \"{}\"", self.input_file);

        if let Some(accel) = &self.hardware_accel {
            command.push_str(&format!(" -hwaccel {}", accel));
        }

        if !self.filters.is_empty() {
            command.push_str(" -vf \"");
            command.push_str(&self.filters.join(","));
            command.push('"');
        }

        command.push_str(&format!(" -c:v {}", self.codec));

        if let Some(quality) = self.quality {
            match self.codec.as_str() {
                "hevc_nvenc" | "h264_nvenc" => {
                    command.push_str(&format!(" -cq {}", quality));
                },
                "h264_amf" | "hevc_amf" => {
                    command.push_str(&format!(" -qp {}", quality));
                },
                "h264_qsv" | "hevc_qsv" => {
                    command.push_str(&format!(" -global_quality {}", quality));
                },
                _ => {
                    command.push_str(&format!(" -crf {}", quality));
                }
            }
        }

        for param in &self.custom_params {
            command.push_str(&format!(" {}", param));
        }

        command.push_str(&format!(" \"{}\"", self.output_file));

        command
    }
}
