mixvideo-v2/cargos/tvai-v2/tests/ffmpeg_config_tests.rs

use tvai_sdk::{TvaiSdk, TemplateBuilder};

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_audio_codec_loading() {
        let sdk = TvaiSdk::new();
        let audio_codecs = sdk.ffmpeg_generator.get_available_audio_codecs();

        // 检查是否加载了内置音频编解码器
        assert!(!audio_codecs.is_empty(), "应该加载内置音频编解码器配置");

        // 检查 AAC 编解码器
        let aac_codec = sdk.ffmpeg_generator.get_audio_codec("AAC");
        assert!(aac_codec.is_some(), "应该找到 AAC 编解码器");

        if let Some(aac) = aac_codec {
            assert_eq!(aac.name, "AAC");
            assert!(aac.ffmpeg_opts.contains("aac"), "AAC 编解码器应该包含 'aac' 选项");
            assert!(aac.ext.contains(&"mp4".to_string()), "AAC 应该支持 MP4 格式");
        }
    }

    #[test]
    fn test_video_encoder_loading() {
        let sdk = TvaiSdk::new();
        let video_encoders = sdk.ffmpeg_generator.get_available_video_encoders();

        // 检查是否加载了内置视频编码器
        assert!(!video_encoders.is_empty(), "应该加载内置视频编码器配置");

        // 检查 H.264 编码器
        let h264_encoder = sdk.ffmpeg_generator.get_video_encoder_by_name("H264");
        assert!(h264_encoder.is_some(), "应该找到 H.264 编码器");
    }

    #[test]
    fn test_model_recommendation() {
        let sdk = TvaiSdk::new();
        
        // 测试不同分辨率的模型推荐
        let recommendations_480p = sdk.ffmpeg_generator.recommend_model_for_resolution(480);
        assert!(!recommendations_480p.is_empty(), "480p 应该有模型推荐");
        
        let recommendations_1080p = sdk.ffmpeg_generator.recommend_model_for_resolution(1080);
        assert!(!recommendations_1080p.is_empty(), "1080p 应该有模型推荐");
        
        let recommendations_4k = sdk.ffmpeg_generator.recommend_model_for_resolution(2160);
        assert!(!recommendations_4k.is_empty(), "4K 应该有模型推荐");
    }

    #[test]
    fn test_audio_codec_params_generation() {
        let sdk = TvaiSdk::new();
        
        // 测试 AAC 编解码器参数生成
        let aac_params = sdk.ffmpeg_generator.generate_audio_codec_params("AAC", Some(192));
        assert!(aac_params.contains("-c:a"), "应该包含音频编解码器参数");
        assert!(aac_params.contains("192"), "应该包含指定的比特率");
        
        // 测试不存在的编解码器
        let unknown_params = sdk.ffmpeg_generator.generate_audio_codec_params("UNKNOWN", Some(128));
        assert!(unknown_params.contains("-c:a UNKNOWN"), "应该回退到默认格式");
    }

    #[test]
    fn test_compatibility_filtering() {
        let sdk = TvaiSdk::new();
        
        // 测试 Windows 兼容性筛选
        let windows_encoders = sdk.ffmpeg_generator.get_compatible_video_encoders("windows", None);
        assert!(!windows_encoders.is_empty(), "应该有 Windows 兼容的编码器");
        
        // 测试 macOS 兼容性筛选
        let macos_encoders = sdk.ffmpeg_generator.get_compatible_video_encoders("osx", None);
        assert!(!macos_encoders.is_empty(), "应该有 macOS 兼容的编码器");
        
        // 测试 GPU 筛选
        let _nvidia_encoders = sdk.ffmpeg_generator.get_compatible_video_encoders("windows", Some("nvidia"));
        // 注意：这个测试可能为空，因为需要特定的配置
        
        // 测试文件扩展名筛选
        let mp4_encoders = sdk.ffmpeg_generator.get_encoders_for_extension("mp4");
        assert!(!mp4_encoders.is_empty(), "应该有支持 MP4 的编码器");
    }

    #[test]
    fn test_auto_encoder_selection() {
        let sdk = TvaiSdk::new();
        
        // 创建测试模板
        let template = TemplateBuilder::new("测试模板")
            .enable_enhancement("prob-4")
            .build()
            .expect("应该能创建测试模板");
        
        // 测试自动编码器选择
        let result = sdk.ffmpeg_generator.generate_with_auto_encoder(
            &template, 
            "input.mp4", 
            "output.mp4", 
            "windows", 
            Some("nvidia")
        );
        
        // 这个测试可能失败，因为需要特定的编码器配置
        // 但至少应该返回一个结果（成功或特定的错误）
        assert!(result.is_ok() || result.is_err(), "应该返回结果");
    }

    #[test]
    fn test_ffmpeg_command_with_config() {
        let sdk = TvaiSdk::new();
        
        // 创建使用配置文件的模板
        let template = TemplateBuilder::new("配置文件测试")
            .enable_enhancement("prob-4")
            .video_codec("H264", Some(23))
            .audio_settings("AAC", 192, 2)
            .build()
            .expect("应该能创建模板");
        
        // 生成 FFmpeg 命令
        let command = sdk.generate_ffmpeg_command(&template, "input.mp4", "output.mp4")
            .expect("应该能生成 FFmpeg 命令");
        
        // 验证命令包含预期的元素
        assert!(command.contains("ffmpeg"), "应该包含 ffmpeg");
        assert!(command.contains("-i"), "应该包含输入参数");
        assert!(command.contains("tvai_up"), "应该包含 TVAI 增强滤镜");
        assert!(command.contains("-c:a"), "应该包含音频编解码器");
    }

    #[test]
    fn test_encoder_report_generation() {
        let sdk = TvaiSdk::new();
        
        let report = sdk.ffmpeg_generator.generate_encoder_report();
        
        // 验证报告包含预期的内容
        assert!(report.contains("可用编码器报告"), "应该包含报告标题");
        assert!(report.contains("音频编解码器"), "应该包含音频编解码器部分");
        
        // 如果有编码器配置，应该包含编码器信息
        if !sdk.ffmpeg_generator.get_available_video_encoders().is_empty() {
            assert!(report.len() > 100, "报告应该有实质内容");
        }
    }

    #[test]
    fn test_bitrate_config_usage() {
        let sdk = TvaiSdk::new();
        
        // 测试 AAC 编解码器的比特率配置
        if let Some(aac_codec) = sdk.ffmpeg_generator.get_audio_codec("AAC") {
            if let Some(bitrate_config) = &aac_codec.bitrate {
                assert!(bitrate_config.min > 0, "最小比特率应该大于 0");
                assert!(bitrate_config.max > bitrate_config.min, "最大比特率应该大于最小比特率");
                assert!(!bitrate_config.suggested.is_empty(), "应该有建议的比特率值");
                assert!(bitrate_config.ffmpeg_opt.contains("<BITRATE>"), "应该包含比特率占位符");
            }
        }
    }

    #[test]
    fn test_video_encoder_quality_modes() {
        let sdk = TvaiSdk::new();
        
        // 查找支持质量模式的编码器
        for encoder in sdk.ffmpeg_generator.get_available_video_encoders() {
            if let Some(bitrate_opts) = &encoder.bitrate_opts {
                if bitrate_opts.cbr.is_some() {
                    assert!(bitrate_opts.cbr.as_ref().unwrap().contains("<CONST_BITRATE_VALUE>"), 
                           "CBR 模板应该包含比特率占位符");
                }
                
                if bitrate_opts.vbr.is_some() {
                    let vbr_template = bitrate_opts.vbr.as_ref().unwrap();
                    assert!(vbr_template.contains("<QP_VALUE>") || 
                           vbr_template.contains("<QPI_VALUE>") ||
                           vbr_template.contains("<QV_VALUE>"), 
                           "VBR 模板应该包含质量占位符");
                }
            }
        }
    }
}