// ================================================================================================
// Audio Backend - 音频缓冲区转换测试
// ================================================================================================

#include <gtest/gtest.h>
#include "engine/audio_buffer.h"
#include "tests/common/test_fixtures.h"
#include "tests/common/test_utils.h"

using namespace audio_backend;
using namespace audio_backend::engine;

// 音频缓冲区格式转换测试固定装置
class AudioBufferConversionTest : public test::AudioEngineTest {
protected:
    void SetUp() override {
        test::AudioEngineTest::SetUp();
        
        // 准备不同格式的测试值
        int16_max_ = std::numeric_limits<int16_t>::max();
        int24_max_ = 8388607;  // 2^23 - 1
        int32_max_ = std::numeric_limits<int32_t>::max();
        
        // 创建标准测试数据
        setup_test_buffers();
    }
    
    void TearDown() override {
        test::AudioEngineTest::TearDown();
    }
    
    // 设置不同格式的测试缓冲区
    void setup_test_buffers() {
        // 浮点数据 [-1.0, 1.0]
        float_buffer_ = std::make_unique<AudioBuffer>(16, 2, AudioFormat::FLOAT32);
        float* float_data = float_buffer_->interleaved_data<float>();
        for (int i = 0; i < 32; ++i) {  // 16帧 * 2通道
            float_data[i] = (i % 2 == 0) ? 1.0f * i / 31.0f : -1.0f * i / 31.0f;
        }
        
        // INT16数据 [-32768, 32767]
        int16_buffer_ = std::make_unique<AudioBuffer>(16, 2, AudioFormat::INT16);
        int16_t* int16_data = int16_buffer_->interleaved_data<int16_t>();
        for (int i = 0; i < 32; ++i) {
            int16_data[i] = (i % 2 == 0) ? static_cast<int16_t>(int16_max_ * i / 31) : 
                                           static_cast<int16_t>(-int16_max_ * i / 31);
        }
        
        // INT32数据 [-2147483648, 2147483647]
        int32_buffer_ = std::make_unique<AudioBuffer>(16, 2, AudioFormat::INT32);
        int32_t* int32_data = int32_buffer_->interleaved_data<int32_t>();
        for (int i = 0; i < 32; ++i) {
            int32_data[i] = (i % 2 == 0) ? static_cast<int32_t>(int32_max_ * i / 31) : 
                                           static_cast<int32_t>(-int32_max_ * i / 31);
        }
    }
    
    // 测试辅助函数
    
    // 检查Float32到Int16转换的精度
    void check_float_to_int16(const AudioBuffer& source, const AudioBuffer& converted) {
        const float* src_data = source.interleaved_data<float>();
        const int16_t* conv_data = converted.interleaved_data<int16_t>();
        
        for (size_t i = 0; i < source.frames() * source.channels(); ++i) {
            int16_t expected = static_cast<int16_t>(src_data[i] * int16_max_);
            EXPECT_NEAR(conv_data[i], expected, 1) << "at index " << i;
        }
    }
    
    // 检查Int16到Float32转换的精度
    void check_int16_to_float(const AudioBuffer& source, const AudioBuffer& converted) {
        const int16_t* src_data = source.interleaved_data<int16_t>();
        const float* conv_data = converted.interleaved_data<float>();
        
        for (size_t i = 0; i < source.frames() * source.channels(); ++i) {
            float expected = static_cast<float>(src_data[i]) / int16_max_;
            EXPECT_NEAR(conv_data[i], expected, 1.0f/int16_max_) << "at index " << i;
        }
    }
    
    // 检查Float32到Int32转换的精度
    void check_float_to_int32(const AudioBuffer& source, const AudioBuffer& converted) {
        const float* src_data = source.interleaved_data<float>();
        const int32_t* conv_data = converted.interleaved_data<int32_t>();
        
        for (size_t i = 0; i < source.frames() * source.channels(); ++i) {
            int32_t expected = static_cast<int32_t>(src_data[i] * int32_max_);
            // 允许一定的误差范围，因为浮点转整型有精度损失
            EXPECT_NEAR(conv_data[i], expected, 256) << "at index " << i;
        }
    }
    
    // 检查Int32到Float32转换的精度
    void check_int32_to_float(const AudioBuffer& source, const AudioBuffer& converted) {
        const int32_t* src_data = source.interleaved_data<int32_t>();
        const float* conv_data = converted.interleaved_data<float>();
        
        for (size_t i = 0; i < source.frames() * source.channels(); ++i) {
            float expected = static_cast<float>(src_data[i]) / int32_max_;
            EXPECT_NEAR(conv_data[i], expected, 1.0f/int32_max_) << "at index " << i;
        }
    }

protected:
    std::unique_ptr<AudioBuffer> float_buffer_;
    std::unique_ptr<AudioBuffer> int16_buffer_;
    std::unique_ptr<AudioBuffer> int32_buffer_;
    
    int16_t int16_max_;
    int32_t int24_max_;
    int32_t int32_max_;
};

// 测试Float32到INT16的转换
TEST_F(AudioBufferConversionTest, Float32ToInt16Conversion) {
    AudioBuffer converted = float_buffer_->convert_format(AudioFormat::INT16);
    
    EXPECT_EQ(converted.format(), AudioFormat::INT16);
    EXPECT_EQ(converted.channels(), float_buffer_->channels());
    EXPECT_EQ(converted.frames(), float_buffer_->frames());
    
    check_float_to_int16(*float_buffer_, converted);
}

// 测试INT16到Float32的转换
TEST_F(AudioBufferConversionTest, Int16ToFloat32Conversion) {
    AudioBuffer converted = int16_buffer_->convert_format(AudioFormat::FLOAT32);
    
    EXPECT_EQ(converted.format(), AudioFormat::FLOAT32);
    EXPECT_EQ(converted.channels(), int16_buffer_->channels());
    EXPECT_EQ(converted.frames(), int16_buffer_->frames());
    
    check_int16_to_float(*int16_buffer_, converted);
}

// 测试Float32到INT32的转换
TEST_F(AudioBufferConversionTest, Float32ToInt32Conversion) {
    AudioBuffer converted = float_buffer_->convert_format(AudioFormat::INT32);
    
    EXPECT_EQ(converted.format(), AudioFormat::INT32);
    EXPECT_EQ(converted.channels(), float_buffer_->channels());
    EXPECT_EQ(converted.frames(), float_buffer_->frames());
    
    check_float_to_int32(*float_buffer_, converted);
}

// 测试INT32到Float32的转换
TEST_F(AudioBufferConversionTest, Int32ToFloat32Conversion) {
    AudioBuffer converted = int32_buffer_->convert_format(AudioFormat::FLOAT32);
    
    EXPECT_EQ(converted.format(), AudioFormat::FLOAT32);
    EXPECT_EQ(converted.channels(), int32_buffer_->channels());
    EXPECT_EQ(converted.frames(), int32_buffer_->frames());
    
    check_int32_to_float(*int32_buffer_, converted);
}

// 测试INT16到INT32的转换
TEST_F(AudioBufferConversionTest, Int16ToInt32Conversion) {
    AudioBuffer converted = int16_buffer_->convert_format(AudioFormat::INT32);
    
    EXPECT_EQ(converted.format(), AudioFormat::INT32);
    EXPECT_EQ(converted.channels(), int16_buffer_->channels());
    EXPECT_EQ(converted.frames(), int16_buffer_->frames());
    
    // 验证转换
    const int16_t* src_data = int16_buffer_->interleaved_data<int16_t>();
    const int32_t* conv_data = converted.interleaved_data<int32_t>();
    
    for (size_t i = 0; i < int16_buffer_->frames() * int16_buffer_->channels(); ++i) {
        // INT16到INT32: 左移16位
        int32_t expected = static_cast<int32_t>(src_data[i]) << 16;
        EXPECT_EQ(conv_data[i], expected) << "at index " << i;
    }
}

// 测试INT32到INT16的转换
TEST_F(AudioBufferConversionTest, Int32ToInt16Conversion) {
    AudioBuffer converted = int32_buffer_->convert_format(AudioFormat::INT16);
    
    EXPECT_EQ(converted.format(), AudioFormat::INT16);
    EXPECT_EQ(converted.channels(), int32_buffer_->channels());
    EXPECT_EQ(converted.frames(), int32_buffer_->frames());
    
    // 验证转换
    const int32_t* src_data = int32_buffer_->interleaved_data<int32_t>();
    const int16_t* conv_data = converted.interleaved_data<int16_t>();
    
    for (size_t i = 0; i < int32_buffer_->frames() * int32_buffer_->channels(); ++i) {
        // INT32到INT16: 右移16位并截断
        int16_t expected = static_cast<int16_t>(src_data[i] >> 16);
        EXPECT_EQ(conv_data[i], expected) << "at index " << i;
    }
}

// 测试相同格式间的转换（应该是高效的复制）
TEST_F(AudioBufferConversionTest, SameFormatConversion) {
    AudioBuffer converted = float_buffer_->convert_format(AudioFormat::FLOAT32);
    
    EXPECT_EQ(converted.format(), AudioFormat::FLOAT32);
    EXPECT_EQ(converted.channels(), float_buffer_->channels());
    EXPECT_EQ(converted.frames(), float_buffer_->frames());
    
    // 数据应该完全相同
    const float* src_data = float_buffer_->interleaved_data<float>();
    const float* conv_data = converted.interleaved_data<float>();
    
    for (size_t i = 0; i < float_buffer_->frames() * float_buffer_->channels(); ++i) {
        EXPECT_FLOAT_EQ(conv_data[i], src_data[i]) << "at index " << i;
    }
}

// 测试无效格式转换
TEST_F(AudioBufferConversionTest, InvalidFormatConversion) {
    // 转换为未知格式应该抛出异常
    EXPECT_THROW(float_buffer_->convert_format(AudioFormat::UNKNOWN), common::AudioException);
}

// 测试重采样功能
TEST_F(AudioBufferConversionTest, Resampling) {
    // 创建44.1kHz的缓冲区
    AudioConfig config;
    config.sample_rate = 44100;
    config.channels = 2;
    config.format = AudioFormat::FLOAT32;
    config.frames_per_buffer = 100;
    
    AudioBuffer original(config);
    
    // 填充数据（简单的正弦波）
    float* data = original.interleaved_data<float>();
    for (size_t i = 0; i < config.frames_per_buffer; ++i) {
        float t = static_cast<float>(i) / config.sample_rate;
        float sample = std::sin(2.0f * M_PI * 440.0f * t);  // 440Hz正弦波
        data[i * 2] = sample;
        data[i * 2 + 1] = sample;
    }
    
    // 重采样到48kHz
    uint32_t new_sample_rate = 48000;
    AudioBuffer resampled = original.resample(new_sample_rate);
    
    // 检查基本属性
    EXPECT_EQ(resampled.sample_rate(), new_sample_rate);
    EXPECT_EQ(resampled.channels(), original.channels());
    EXPECT_EQ(resampled.format(), original.format());
    
    // 新帧数应该成比例变化
    float ratio = static_cast<float>(new_sample_rate) / original.sample_rate();
    size_t expected_frames = static_cast<size_t>(original.frames() * ratio);
    EXPECT_EQ(resampled.frames(), expected_frames);
}

int main(int argc, char** argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}