/**
 * @file test_audio_processing_comprehensive.cpp
 * @brief 音频处理函数综合测试套件
 * 
 * 测试覆盖：
 * - 9个音频处理函数确性测试
 * - 标量与SIMD版本的一致性测试
 * - 边界条件和错误处理测试
 * - 性能对比测试
 * - 跨平台兼容性测试
 */

#include <gtest/gtest.h>
#include <vector>
#include <cmath>
#include <random>
#include <chrono>
#include <iomanip>
#include <algorithm>
#include <numeric>
#include <functional>

// 确保M_PI定义可用
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

// 音频处理函数头文件
#include "aligned_allocator.h"
#include "simd_func_dispatcher.h"
#include "audio_processing/scalar_audio_processing_func.h"
#include "audio_processing/simd_audio_processing.h"

#if ALICHO_PLATFORM_X86
#include "audio_processing/x86_simd_audio_processing_func.h"
#endif

#if ALICHO_PLATFORM_ARM
#include "audio_processing/arm_simd_audio_processing_func.h"
#endif

// 测试容差设置
constexpr float FLOAT_TOLERANCE = 1e-6f;
constexpr float RMS_TOLERANCE   = 1e-5f;
constexpr float PEAK_TOLERANCE  = 1e-6f;

// 性能测试设置
constexpr size_t PERF_TEST_SIZE       = 1024 * 1024; // 1M samples
constexpr int    PERF_TEST_ITERATIONS = 100;

using aligned_audio_buffer = std::vector<float, avx512_aligned_allocator<float>>;

/**
 * 浮点数比较函数
 */
bool float_equal(float a, float b, float tolerance = FLOAT_TOLERANCE) {
	if (std::isnan(a) && std::isnan(b))
		return true;
	if (std::isinf(a) && std::isinf(b))
		return (a > 0) == (b > 0);
	return std::abs(a - b) <= tolerance;
}

/**
 * 数组比较函数
 */
bool arrays_equal(const float* arr1, const float* arr2, size_t size, float tolerance = FLOAT_TOLERANCE) {
	for (size_t i = 0; i < size; ++i) {
		if (!float_equal(arr1[i], arr2[i], tolerance)) {
			std::cout << "    差异在位置 " << i << ": " << arr1[i] << " vs " << arr2[i]
					<< " (差值: " << std::abs(arr1[i] - arr2[i]) << ")" << std::endl;
			return false;
		}
	}
	return true;
}

/**
 * 测试数据生成器
 */
class AudioDataGenerator {
private:
	mutable std::mt19937 rng_{std::random_device{}()};

public:
	// 生成正弦波
	auto generate_sine_wave(size_t num_samples, float frequency = 440.0f,
	                        float  sample_rate                  = 44100.0f, float amplitude = 1.0f) const {
		std::vector<float, aligned_allocator<float, ALIGNMENT_AVX512>> data(num_samples);
		for (size_t i = 0; i < num_samples; ++i) {
			data[i] = amplitude * std::sin(2.0f * M_PI * frequency * i / sample_rate);
		}
		return data;
	}

	// 生成白噪声
	auto generate_white_noise(size_t num_samples, float amplitude = 1.0f) const {
		std::vector<float, aligned_allocator<float, ALIGNMENT_AVX512>> data(num_samples);
		std::uniform_real_distribution<float>                          dist(-amplitude, amplitude);
		for (size_t i = 0; i < num_samples; ++i) {
			data[i] = dist(rng_);
		}
		return data;
	}

	// 生成脉冲信号
	auto generate_impulse(size_t num_samples, size_t impulse_pos = 0, float amplitude = 1.0f) const {
		std::vector<float, aligned_allocator<float, ALIGNMENT_AVX512>> data(num_samples, 0.0f);
		if (impulse_pos < num_samples) {
			data[impulse_pos] = amplitude;
		}
		return data;
	}

	// 生成直流信号
	aligned_audio_buffer generate_dc(size_t num_samples, float value = 1.0f) const {
		return aligned_audio_buffer(num_samples, value);
	}

	// 生成立体声测试数据
	aligned_audio_buffer generate_stereo_test_data(size_t num_stereo_samples) const {
		aligned_audio_buffer data(num_stereo_samples * 2);
		for (size_t i = 0; i < num_stereo_samples; ++i) {
			data[i * 2]     = std::sin(2.0f * M_PI * 440.0f * i / 44100.0f); // 左声道: 440Hz
			data[i * 2 + 1] = std::sin(2.0f * M_PI * 880.0f * i / 44100.0f); // 右声道: 880Hz
		}
		return data;
	}

	// 生成边界测试数据
	aligned_audio_buffer generate_boundary_data(size_t num_samples) const {
		aligned_audio_buffer data;
		data.reserve(num_samples);

		// 添加各种边界值
		if (num_samples > 0)
			data.push_back(0.0f);
		if (num_samples > 1)
			data.push_back(1.0f);
		if (num_samples > 2)
			data.push_back(-1.0f);
		if (num_samples > 3)
			data.push_back(std::numeric_limits<float>::min());
		if (num_samples > 4)
			data.push_back(std::numeric_limits<float>::max());
		if (num_samples > 5)
			data.push_back(std::numeric_limits<float>::epsilon());
		if (num_samples > 6)
			data.push_back(-std::numeric_limits<float>::epsilon());

		// 填充剩余位置
		std::uniform_real_distribution<float> dist(-1.0f, 1.0f);
		while (data.size() < num_samples) {
			data.push_back(dist(rng_));
		}

		return data;
	}
};

/**
 * 性能测试辅助类
 */
class PerformanceTester {
public:
	template <typename Func>
	double measure_execution_time(Func&& func, int iterations = PERF_TEST_ITERATIONS) {
		auto start = std::chrono::high_resolution_clock::now();

		for (int i = 0; i < iterations; ++i) {
			func();
		}

		auto end      = std::chrono::high_resolution_clock::now();
		auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start);

		return duration.count() / 1e6 / iterations; // 返回平均毫秒数
	}

	void print_performance_comparison(const std::string& test_name,
	                                  double             scalar_time,
	                                  double             simd_time) {
		double speedup = scalar_time / simd_time;
		std::cout << "[PERF] " << test_name << std::endl;
		std::cout << "       标量版本: " << std::fixed << std::setprecision(3) << scalar_time << "ms" << std::endl;
		std::cout << "       SIMD版本: " << std::fixed << std::setprecision(3) << simd_time << "ms" << std::endl;
		std::cout << "       加速比: " << std::fixed << std::setprecision(2) << speedup << "x" << std::endl;
	}
};

// 音频处理函数测试类
class AudioProcessingTest : public ::testing::Test {
protected:
	void SetUp() override {
		// 初始化测试环境
		audio_processing_registry::register_all_functions();
	}

	void TearDown() override {
		// 清理测试环境
	}

	// 全局实例
	AudioDataGenerator data_gen;
	PerformanceTester  perf_tester;
};

/**
 * ========================================
 * 基础功能测试
 * ========================================
 */

// 测试 simd_audio_processing_registry 注册功能
TEST_F(AudioProcessingTest, RegistryRegistration) {
	// 打印已注册的函数以供调试
	audio_processing_registry::print_available_functions();

	// 验证关键函数已注册
	auto& dispatcher = simd_func_dispatcher::instance();

	EXPECT_NO_THROW({
		dispatcher.get_function<void(const float*, const float*, float*, size_t)>("mix_audio");
		}) << "函数 mix_audio 未正确注册";

	EXPECT_NO_THROW({
		dispatcher.get_function<void(const float*, float*, float, size_t)>("apply_gain");
		}) << "函数 apply_gain 未正确注册";

	EXPECT_NO_THROW({
		dispatcher.get_function<float(const float*, size_t)>("calculate_rms");
		}) << "函数 calculate_rms 未正确注册";

	EXPECT_NO_THROW({
		dispatcher.get_function<float(const float*, size_t)>("calculate_peak");
		}) << "函数 calculate_peak 未正确注册";

	EXPECT_NO_THROW({
		dispatcher.get_function<void(const float*, float*, float, size_t)>("normalize_audio");
		}) << "函数 normalize_audio 未正确注册";

	EXPECT_NO_THROW({
		dispatcher.get_function<void(const float*, float*, size_t)>("stereo_to_mono");
		}) << "函数 stereo_to_mono 未正确注册";
}

// 测试 mix_audio 函数
TEST_F(AudioProcessingTest, MixAudioBasic) {
	const size_t         num_samples = 16;
	auto                 src1        = data_gen.generate_sine_wave(num_samples, 440.0f);
	auto                 src2        = data_gen.generate_sine_wave(num_samples, 880.0f);
	aligned_audio_buffer result(num_samples);
	aligned_audio_buffer expected(num_samples);

	// 计算期望结果
	for (size_t i = 0; i < num_samples; ++i) {
		expected[i] = src1[i] + src2[i];
	}

	// 测试标量版本
	scalar_audio_processing_func::mix_audio(src1.data(), src2.data(), result.data(), num_samples);

	EXPECT_TRUE(arrays_equal(result.data(), expected.data(), num_samples))
        << "混合音频结果与期望不符";
}

// 测试 apply_gain 函数
TEST_F(AudioProcessingTest, ApplyGainBasic) {
	const size_t                                        num_samples = 16;
	const float                                         gain        = 0.5f;
	auto                                                src         = data_gen.generate_sine_wave(num_samples);
	std::vector<float, avx512_aligned_allocator<float>> result(num_samples);
	std::vector<float, avx512_aligned_allocator<float>> expected(num_samples);

	// 计算期望结果
	for (size_t i = 0; i < num_samples; ++i) {
		expected[i] = src[i] * gain;
	}

	// 测试标量版本
	scalar_audio_processing_func::apply_gain(src.data(), result.data(), gain, num_samples);

	EXPECT_TRUE(arrays_equal(result.data(), expected.data(), num_samples))
        << "增益应用结果与期望不符";
}

// 测试 calculate_rms 函数
TEST_F(AudioProcessingTest, CalculateRmsBasic) {
	const size_t num_samples = 1024;
	auto         src         = data_gen.generate_sine_wave(num_samples);

	// 计算期望的RMS值
	double sum_squares = 0.0;
	for (size_t i = 0; i < num_samples; ++i) {
		sum_squares += src[i] * src[i];
	}
	float expected_rms = std::sqrt(sum_squares / num_samples);

	// 测试标量版本
	float result_rms = scalar_audio_processing_func::calculate_rms(src.data(), num_samples);

	EXPECT_TRUE(float_equal(result_rms, expected_rms, RMS_TOLERANCE))
        << "期望 RMS: " << expected_rms << ", 得到: " << result_rms;
}

// 测试 calculate_peak 函数
TEST_F(AudioProcessingTest, CalculatePeakBasic) {
	const size_t num_samples = 1024;
	auto         src         = data_gen.generate_boundary_data(num_samples);

	// 计算期望的峰值
	float expected_peak = 0.0f;
	for (size_t i = 0; i < num_samples; ++i) {
		expected_peak = std::max(expected_peak, std::abs(src[i]));
	}

	// 测试标量版本
	float result_peak = scalar_audio_processing_func::calculate_peak(src.data(), num_samples);

	EXPECT_TRUE(float_equal(result_peak, expected_peak, PEAK_TOLERANCE))
        << "期望峰值: " << expected_peak << ", 得到: " << result_peak;
}

/**
 * ========================================
 * 新增功能测试
 * ========================================
 */

// 测试 normalize_audio 函数
TEST_F(AudioProcessingTest, NormalizeAudioBasic) {
	const size_t         num_samples = 1024;
	const float          target_peak = 0.8f;
	auto                 src         = data_gen.generate_sine_wave(num_samples, 440.0f, 44100.0f, 2.0f); // 超过1.0的幅度
	aligned_audio_buffer result(num_samples);

	// 测试标量版本
	scalar_audio_processing_func::normalize_audio(src.data(), result.data(), target_peak, num_samples);

	// 验证归一化后的峰值
	float actual_peak = scalar_audio_processing_func::calculate_peak(result.data(), num_samples);

	EXPECT_TRUE(float_equal(actual_peak, target_peak, PEAK_TOLERANCE))
        << "期望峰值: " << target_peak << ", 实际峰值: " << actual_peak;
}

// 测试 stereo_to_mono 函数
TEST_F(AudioProcessingTest, StereoToMonoBasic) {
	const size_t         num_stereo_samples = 512;
	auto                 stereo_src         = data_gen.generate_stereo_test_data(num_stereo_samples);
	aligned_audio_buffer mono_result(num_stereo_samples);
	aligned_audio_buffer expected_mono(num_stereo_samples);

	// 计算期望结果
	for (size_t i = 0; i < num_stereo_samples; ++i) {
		expected_mono[i] = (stereo_src[i * 2] + stereo_src[i * 2 + 1]) * 0.5f;
	}

	// 测试标量版本
	scalar_audio_processing_func::stereo_to_mono(stereo_src.data(), mono_result.data(), num_stereo_samples);

	EXPECT_TRUE(arrays_equal(mono_result.data(), expected_mono.data(), num_stereo_samples))
        << "立体声转单声道果与期望不符";
}

// 测试 limit_audio 函数
TEST_F(AudioProcessingTest, LimitAudioBasic) {
	const size_t         num_samples = 1024;
	const float          threshold   = 0.5f;
	auto                 src         = data_gen.generate_sine_wave(num_samples, 440.0f, 44100.0f, 1.0f);
	aligned_audio_buffer result(num_samples);
	float                limiter_state = 1.0f;

	// 测试标量版本
	scalar_audio_processing_func::limit_audio(src.data(), result.data(), threshold, &limiter_state, 44100.f,
	                                          num_samples);

	// 验证没有样本超过阈值
	bool   all_samples_limited = true;
	size_t violation_index     = 0;
	float  violation_value     = 0.0f;

	for (size_t i = 0; i < num_samples; ++i) {
		if (std::abs(result[i]) > threshold + FLOAT_TOLERANCE) {
			all_samples_limited = false;
			violation_index     = i;
			violation_value     = result[i];
			break;
		}
	}

	EXPECT_TRUE(all_samples_limited)
        << "样本 " << violation_index << " 超过阈值: " << violation_value;
}

// 测试 fade_audio 函数
TEST_F(AudioProcessingTest, FadeAudioBasic) {
	const size_t         num_samples      = 1024;
	const size_t         fade_in_samples  = 100;
	const size_t         fade_out_samples = 100;
	auto                 src              = data_gen.generate_dc(num_samples, 1.0f);
	aligned_audio_buffer result(num_samples);

	// 测试标量版本
	scalar_audio_processing_func::fade_audio(src.data(), result.data(), fade_in_samples, fade_out_samples, num_samples);

	// 验证淡入淡出效果

	// 检查淡入部分
	EXPECT_FLOAT_EQ(result[0], 0.0f)
        << "淡入开始应为0，实际为: " << result[0];

	// 检查中间部分（应该是1.0）
	EXPECT_FLOAT_EQ(result[num_samples / 2], 1.0f)
        << "中间部分应保持原始值1.0，实际为: " << result[num_samples / 2];

	// 检查淡出部分
	EXPECT_TRUE(float_equal(result[num_samples - 1], 0.0f, FLOAT_TOLERANCE))
        << "淡出结束应为0，实际为: " << result[num_samples - 1];
}

// 测试 simple_eq 函数
TEST_F(AudioProcessingTest, SimpleEqBasic) {
	const size_t         num_samples = 1024;
	const float          low_gain    = 1.2f;
	const float          mid_gain    = 1.0f;
	const float          high_gain   = 0.8f;
	auto                 src         = data_gen.generate_white_noise(num_samples, 0.5f);
	aligned_audio_buffer result(num_samples);
	aligned_audio_buffer eq_state(2, 0.0f); // 低通和高通滤波器状态

	// 测试标量版本
	scalar_audio_processing_func::simple_eq(src.data(), result.data(), low_gain, mid_gain, high_gain, eq_state.data(),
	                                        num_samples);

	// 基本验证：结果不应该全为零（除非输入全为零）
	bool has_nonzero = false;
	for (size_t i = 0; i < num_samples; ++i) {
		if (result[i] != 0.0f) {
			has_nonzero = true;
			break;
		}
	}

	EXPECT_TRUE(has_nonzero)
        << "EQ处理后的结果全为零，可能存在处理错误";
}

/**
 * ========================================
 * 边界条件测试
 * ========================================
 */

// 测试零长度输入
TEST_F(AudioProcessingTest, ZeroLengthInput) {
	const size_t         num_samples = 0;
	aligned_audio_buffer dummy(1, 0.0f);
	aligned_audio_buffer result(1, 0.0f);
	float                state = 1.0f;

	// 这些函数应该能安全处理零长度输入
	EXPECT_NO_THROW({
		scalar_audio_processing_func::mix_audio(dummy.data(), dummy.data(), result.data(), num_samples);
		scalar_audio_processing_func::apply_gain(dummy.data(), result.data(), 1.0f, num_samples);
		scalar_audio_processing_func::normalize_audio(dummy.data(), result.data(), 1.0f, num_samples);
		scalar_audio_processing_func::stereo_to_mono(dummy.data(), result.data(), num_samples);
		scalar_audio_processing_func::limit_audio(dummy.data(), result.data(), 1.0f, &state, 44100.f, num_samples);
		scalar_audio_processing_func::fade_audio(dummy.data(), result.data(), 0, 0, num_samples);
		scalar_audio_processing_func::simple_eq(dummy.data(), result.data(), 1.0f, 1.0f, 1.0f, &state, num_samples);
		});
}

// 测试单样本输入
TEST_F(AudioProcessingTest, SingleSampleInput) {
	const size_t         num_samples = 1;
	aligned_audio_buffer src1{0.5f};
	aligned_audio_buffer src2{0.3f};
	aligned_audio_buffer result(1);
	float                state = 1.0f;

	// 测试混合
	scalar_audio_processing_func::mix_audio(src1.data(), src2.data(), result.data(), num_samples);
	EXPECT_TRUE(float_equal(result[0], 0.8f))
        << "混合单样本: 期望0.8，实际" << result[0];

	// 测试增益
	scalar_audio_processing_func::apply_gain(src1.data(), result.data(), 2.0f, num_samples);
	EXPECT_TRUE(float_equal(result[0], 1.0f))
        << "应用增益: 期望1.0，实际" << result[0];

	// 测试RMS
	float rms = scalar_audio_processing_func::calculate_rms(src1.data(), num_samples);
	EXPECT_TRUE(float_equal(rms, 0.5f))
        << "单样本RMS: 期望0.5，实际" << rms;

	// 测试峰值
	float peak = scalar_audio_processing_func::calculate_peak(src1.data(), num_samples);
	EXPECT_TRUE(float_equal(peak, 0.5f))
        << "单样本峰值: 期望0.5，实际" << peak;
}

// 测试极值处理
TEST_F(AudioProcessingTest, ExtremeValues) {
	const size_t         num_samples    = 8;
	aligned_audio_buffer extreme_values = {
		0.0f,
		1.0f,
		-1.0f,
		std::numeric_limits<float>::max(),
		-std::numeric_limits<float>::max(),
		std::numeric_limits<float>::min(),
		std::numeric_limits<float>::epsilon(),
		-std::numeric_limits<float>::epsilon()
	};

	aligned_audio_buffer result(num_samples);

	// 测试峰值计算对极值的处理
	float peak = scalar_audio_processing_func::calculate_peak(extreme_values.data(), num_samples);
	EXPECT_EQ(peak, std::numeric_limits<float>::max())
        << "极值峰值检测失败，期望" << std::numeric_limits<float>::max() << "，实际" << peak;

	// 测试增益对极值的处理
	scalar_audio_processing_func::apply_gain(extreme_values.data(), result.data(), 0.5f, num_samples);
	bool   all_finite    = true;
	size_t nan_inf_index = 0;

	for (size_t i = 0; i < num_samples; ++i) {
		if (std::isnan(result[i]) || std::isinf(result[i])) {
			all_finite    = false;
			nan_inf_index = i;
			break;
		}
	}

	EXPECT_TRUE(all_finite)
        << "增益处理后在位置" << nan_inf_index << "存在NaN或Inf";
}

/**
 * ========================================
 * 一致性测试（标量 vs SIMD）
 * ========================================
 */

#if ALICHO_PLATFORM_X86

// 测试x86 SIMD版本与标量版的一致性
TEST_F(AudioProcessingTest, X86SimdConsistency) {
	const size_t num_samples = 1024;
	auto         src1        = data_gen.generate_sine_wave(num_samples, 440.0f);
	auto         src2        = data_gen.generate_sine_wave(num_samples, 880.0f);
	auto         stereo_src  = data_gen.generate_stereo_test_data(num_samples);

	aligned_audio_buffer                                           scalar_result(num_samples);
	aligned_audio_buffer                                           sse_result(num_samples);
	aligned_audio_buffer                                           avx_result(num_samples);
	std::vector<float, aligned_allocator<float, ALIGNMENT_AVX512>> avx512_result(num_samples);

	// 测试 mix_audio 一致性
	scalar_audio_processing_func::mix_audio(src1.data(), src2.data(), scalar_result.data(), num_samples);
	x86_simd_audio_processing_func::mix_audio_sse(src1.data(), src2.data(), sse_result.data(), num_samples);
	x86_simd_audio_processing_func::mix_audio_avx(src1.data(), src2.data(), avx_result.data(), num_samples);
	x86_simd_audio_processing_func::mix_audio_avx512(src1.data(), src2.data(), avx512_result.data(), num_samples);

	EXPECT_TRUE(arrays_equal(scalar_result.data(), sse_result.data(), num_samples))
        << "mix_audio SSE版本与标量版本不一致";
	EXPECT_TRUE(arrays_equal(scalar_result.data(), avx_result.data(), num_samples))
        << "mix_audio AVX版本与标量版本不一致";
	EXPECT_TRUE(arrays_equal(scalar_result.data(), avx512_result.data(), num_samples))
        << "mix_audio AVX512版本与标量版本不一致";

	// 测试 apply_gain 一致性
	const float gain = 0.75f;
	scalar_audio_processing_func::apply_gain(src1.data(), scalar_result.data(), gain, num_samples);
	x86_simd_audio_processing_func::apply_gain_sse(src1.data(), sse_result.data(), gain, num_samples);
	x86_simd_audio_processing_func::apply_gain_avx(src1.data(), avx_result.data(), gain, num_samples);
	x86_simd_audio_processing_func::apply_gain_avx512(src1.data(), avx512_result.data(), gain, num_samples);

	EXPECT_TRUE(arrays_equal(scalar_result.data(), sse_result.data(), num_samples))
        << "apply_gain SSE版本与标量版本不一致";
	EXPECT_TRUE(arrays_equal(scalar_result.data(), avx_result.data(), num_samples))
        << "apply_gain AVX版本与标量版本不一致";
	EXPECT_TRUE(arrays_equal(scalar_result.data(), avx512_result.data(), num_samples))
        << "apply_gain AVX512版本与标量版本不一致";

	// 测试 calculate_rms 一致性
	float scalar_rms = scalar_audio_processing_func::calculate_rms(src1.data(), num_samples);
	float sse_rms    = x86_simd_audio_processing_func::calculate_rms_sse(src1.data(), num_samples);
	float avx_rms    = x86_simd_audio_processing_func::calculate_rms_avx(src1.data(), num_samples);
	float avx512_rms = x86_simd_audio_processing_func::calculate_rms_avx512(src1.data(), num_samples);

	EXPECT_TRUE(float_equal(scalar_rms, sse_rms, RMS_TOLERANCE))
        << "calculate_rms SSE版本与标量版本不一致: " << scalar_rms << " vs " << sse_rms;
	EXPECT_TRUE(float_equal(scalar_rms, avx_rms, RMS_TOLERANCE))
        << "calculate_rms AVX版本与标量版本不一致: " << scalar_rms << " vs " << avx_rms;
	EXPECT_TRUE(float_equal(scalar_rms, avx512_rms, RMS_TOLERANCE))
        << "calculate_rms AVX512版本与标量版本不一致: " << scalar_rms << " vs " << avx512_rms;

	// 测试 calculate_peak 一致性
	float scalar_peak = scalar_audio_processing_func::calculate_peak(src1.data(), num_samples);
	float sse_peak    = x86_simd_audio_processing_func::calculate_peak_sse(src1.data(), num_samples);
	float avx_peak    = x86_simd_audio_processing_func::calculate_peak_avx(src1.data(), num_samples);
	float avx512_peak = x86_simd_audio_processing_func::calculate_peak_avx512(src1.data(), num_samples);

	EXPECT_TRUE(float_equal(scalar_peak, sse_peak, PEAK_TOLERANCE))
        << "calculate_peak SSE版本与标量版本不一致: " << scalar_peak << " vs " << sse_peak;
	EXPECT_TRUE(float_equal(scalar_peak, avx_peak, PEAK_TOLERANCE))
        << "calculate_peak AVX版本与标量版本不一致: " << scalar_peak << " vs " << avx_peak;
	EXPECT_TRUE(float_equal(scalar_peak, avx512_peak, PEAK_TOLERANCE))
        << "calculate_peak AVX512版本与标量版本不一致: " << scalar_peak << " vs " << avx512_peak;
}

#endif // ALICHO_PLATFORM_X86

#if ALICHO_PLATFORM_ARM

// 测试ARM NEON版本与标量版的一致性
TEST_F(AudioProcessingTest, ArmSimdConsistency) {
	const size_t num_samples = 1024;
	auto         src1        = data_gen.generate_sine_wave(num_samples, 440.0f);
	auto         src2        = data_gen.generate_sine_wave(num_samples, 880.0f);

	aligned_audio_buffer scalar_result(num_samples);
	aligned_audio_buffer neon_result(num_samples);

	// 测试 mix_audio 一致性
	scalar_audio_processing_func::mix_audio(src1.data(), src2.data(), scalar_result.data(), num_samples);
	arm_simd_audio_processing_func::mix_audio_neon(src1.data(), src2.data(), neon_result.data(), num_samples);

	EXPECT_TRUE(arrays_equal(scalar_result.data(), neon_result.data(), num_samples))
			<< "mix_audio NEON版本与标量版不一致";

	// 测试 apply_gain 一致性
	const float gain = 0.75f;
	scalar_audio_processing_func::apply_gain(src1.data(), scalar_result.data(), gain, num_samples);
	arm_simd_audio_processing_func::apply_gain_neon(src1.data(), neon_result.data(), gain, num_samples);

	EXPECT_TRUE(arrays_equal(scalar_result.data(), neon_result.data(), num_samples))
			<< "apply_gain NEON版本与标量版不一致";

	// 测试 calculate_rms 一致性
	float scalar_rms = scalar_audio_processing_func::calculate_rms(src1.data(), num_samples);
	float neon_rms   = arm_simd_audio_processing_func::calculate_rms_neon(src1.data(), num_samples);

	EXPECT_TRUE(float_equal(scalar_rms, neon_rms, RMS_TOLERANCE))
			<< "calculate_rms NEON版本与标量版不一致: " << scalar_rms << " vs " << neon_rms;

	// 测试 calculate_peak 一致性
	float scalar_peak = scalar_audio_processing_func::calculate_peak(src1.data(), num_samples);
	float neon_peak   = arm_simd_audio_processing_func::calculate_peak_neon(src1.data(), num_samples);

	EXPECT_TRUE(float_equal(scalar_peak, neon_peak, PEAK_TOLERANCE))
			<< "calculate_peak NEON版本与标量版不一致: " << scalar_peak << " vs " << neon_peak;
}

#endif // ALICHO_PLATFORM_ARM

/**
 * ========================================
 * 性能测试
 * ========================================
 */

// 性能测试运行为 TEST_F 测试，但不使用 EXPECT/ASSERT
TEST_F(AudioProcessingTest, PerformanceTests) {
	std::cout << "\n=== 性能测试 ===" << std::endl;

	// 生成大量测试数据
	auto                 src1 = data_gen.generate_sine_wave(PERF_TEST_SIZE, 440.0f);
	auto                 src2 = data_gen.generate_sine_wave(PERF_TEST_SIZE, 880.0f);
	aligned_audio_buffer result(PERF_TEST_SIZE);

	// 性能测试：mix_audio
	{
		double scalar_time = perf_tester.measure_execution_time([&]() {
			scalar_audio_processing_func::mix_audio(src1.data(), src2.data(), result.data(), PERF_TEST_SIZE);
		});

		#if ALICHO_PLATFORM_X86
		double sse_time = perf_tester.measure_execution_time([&]() {
			x86_simd_audio_processing_func::mix_audio_sse(src1.data(), src2.data(), result.data(), PERF_TEST_SIZE);
		});
		perf_tester.print_performance_comparison("mix_audio (SSE vs Scalar)", scalar_time, sse_time);

		double avx_time = perf_tester.measure_execution_time([&]() {
			x86_simd_audio_processing_func::mix_audio_avx(src1.data(), src2.data(), result.data(), PERF_TEST_SIZE);
		});
		perf_tester.print_performance_comparison("mix_audio (AVX vs Scalar)", scalar_time, avx_time);

		double avx512_time = perf_tester.measure_execution_time([&]() {
			x86_simd_audio_processing_func::mix_audio_avx512(src1.data(), src2.data(), result.data(), PERF_TEST_SIZE);
		});
		perf_tester.print_performance_comparison("mix_audio (AVX512 vs Scalar)", scalar_time, avx512_time);
		#endif

		#if ALICHO_PLATFORM_ARM
		double neon_time = perf_tester.measure_execution_time([&]() {
			arm_simd_audio_processing_func::mix_audio_neon(src1.data(), src2.data(), result.data(), PERF_TEST_SIZE);
		});
		perf_tester.print_performance_comparison("mix_audio (NEON vs Scalar)", scalar_time, neon_time);
		#endif
	}

	// 性能测试：apply_gain
	{
		const float gain        = 0.5f;
		double      scalar_time = perf_tester.measure_execution_time([&]() {
			scalar_audio_processing_func::apply_gain(src1.data(), result.data(), gain, PERF_TEST_SIZE);
		});

		#if ALICHO_PLATFORM_X86
		double sse_time = perf_tester.measure_execution_time([&]() {
			x86_simd_audio_processing_func::apply_gain_sse(src1.data(), result.data(), gain, PERF_TEST_SIZE);
		});
		perf_tester.print_performance_comparison("apply_gain (SSE vs Scalar)", scalar_time, sse_time);

		double avx_time = perf_tester.measure_execution_time([&]() {
			x86_simd_audio_processing_func::apply_gain_avx(src1.data(), result.data(), gain, PERF_TEST_SIZE);
		});
		perf_tester.print_performance_comparison("apply_gain (AVX vs Scalar)", scalar_time, avx_time);

		double avx512_time = perf_tester.measure_execution_time([&]() {
			x86_simd_audio_processing_func::apply_gain_avx512(src1.data(), result.data(), gain, PERF_TEST_SIZE);
		});
		perf_tester.print_performance_comparison("apply_gain (AVX512 vs Scalar)", scalar_time, avx512_time);
		#endif

		#if ALICHO_PLATFORM_ARM
		double neon_time = perf_tester.measure_execution_time([&]() {
			arm_simd_audio_processing_func::apply_gain_neon(src1.data(), result.data(), gain, PERF_TEST_SIZE);
		});
		perf_tester.print_performance_comparison("apply_gain (NEON vs Scalar)", scalar_time, neon_time);
		#endif
	}

	// 性能测试：calculate_rms
	{
		double scalar_time = perf_tester.measure_execution_time([&]() {
			scalar_audio_processing_func::calculate_rms(src1.data(), PERF_TEST_SIZE);
		});

		#if ALICHO_PLATFORM_X86
		double sse_time = perf_tester.measure_execution_time([&]() {
			x86_simd_audio_processing_func::calculate_rms_sse(src1.data(), PERF_TEST_SIZE);
		});
		perf_tester.print_performance_comparison("calculate_rms (SSE vs Scalar)", scalar_time, sse_time);

		double avx_time = perf_tester.measure_execution_time([&]() {
			x86_simd_audio_processing_func::calculate_rms_avx(src1.data(), PERF_TEST_SIZE);
		});
		perf_tester.print_performance_comparison("calculate_rms (AVX vs Scalar)", scalar_time, avx_time);

		double avx512_time = perf_tester.measure_execution_time([&]() {
			x86_simd_audio_processing_func::calculate_rms_avx512(src1.data(), PERF_TEST_SIZE);
		});
		perf_tester.print_performance_comparison("calculate_rms (AVX512 vs Scalar)", scalar_time, avx512_time);
		#endif

		#if ALICHO_PLATFORM_ARM
		double neon_time = perf_tester.measure_execution_time([&]() {
			arm_simd_audio_processing_func::calculate_rms_neon(src1.data(), PERF_TEST_SIZE);
		});
		perf_tester.print_performance_comparison("calculate_rms (NEON vs Scalar)", scalar_time, neon_time);
		#endif
	}

	// 性能测试：calculate_peak
	{
		double scalar_time = perf_tester.measure_execution_time([&]() {
			scalar_audio_processing_func::calculate_peak(src1.data(), PERF_TEST_SIZE);
		});

		#if ALICHO_PLATFORM_X86
		double sse_time = perf_tester.measure_execution_time([&]() {
			x86_simd_audio_processing_func::calculate_peak_sse(src1.data(), PERF_TEST_SIZE);
		});
		perf_tester.print_performance_comparison("calculate_peak (SSE vs Scalar)", scalar_time, sse_time);

		double avx_time = perf_tester.measure_execution_time([&]() {
			x86_simd_audio_processing_func::calculate_peak_avx(src1.data(), PERF_TEST_SIZE);
		});
		perf_tester.print_performance_comparison("calculate_peak (AVX vs Scalar)", scalar_time, avx_time);

		double avx512_time = perf_tester.measure_execution_time([&]() {
			x86_simd_audio_processing_func::calculate_peak_avx512(src1.data(), PERF_TEST_SIZE);
		});
		perf_tester.print_performance_comparison("calculate_peak (AVX512 vs Scalar)", scalar_time, avx512_time);
		#endif

		#if ALICHO_PLATFORM_ARM
		double neon_time = perf_tester.measure_execution_time([&]() {
			arm_simd_audio_processing_func::calculate_peak_neon(src1.data(), PERF_TEST_SIZE);
		});
		perf_tester.print_performance_comparison("calculate_peak (NEON vs Scalar)", scalar_time, neon_time);
		#endif
	}
}