#include <gtest/gtest.h>

#include <string>
#include <vector>
#include <thread>
#include <atomic>
#include <mutex>
#include <condition_variable>

#ifdef _WIN32
#define NOMINMAX
#include <windows.h>
#include <mmsystem.h>
#endif

#define private public
#include <XCEngine/Audio/WindowsAudioBackend.h>
#undef private

using namespace XCEngine::Audio;

namespace {

#ifdef _WIN32

TEST(WaveOutBackend, RenderCallbackCanDrivePcm16ConversionForPullModel) {
    WaveOut::WaveOutBackend backend;
    backend.m_config.bufferSize = 2;
    backend.m_config.channels = 2;
    backend.m_config.sampleRate = 48000;

    bool callbackInvoked = false;
    backend.SetRenderCallback(
        [&callbackInvoked](float* buffer, uint32 frameCount, uint32 channels, uint32 sampleRate) {
            callbackInvoked = true;
            EXPECT_EQ(frameCount, 2u);
            EXPECT_EQ(channels, 2u);
            EXPECT_EQ(sampleRate, 48000u);

            buffer[0] = 0.25f;
            buffer[1] = -0.5f;
            buffer[2] = 0.75f;
            buffer[3] = -1.0f;
        });

    backend.m_renderBuffer.assign(4, 0.0f);
    ASSERT_TRUE(static_cast<bool>(backend.m_renderCallback));
    backend.m_renderCallback(backend.m_renderBuffer.data(), 2, 2, 48000);

    std::vector<int16_t> output(4, 0);
    WaveOut::WaveOutBackend::FillPcm16Buffer(output, backend.m_renderBuffer);

    EXPECT_TRUE(backend.UsesPullModel());
    EXPECT_TRUE(callbackInvoked);
    ASSERT_EQ(output.size(), 4u);
    EXPECT_EQ(output[0], 8191);
    EXPECT_EQ(output[1], -16383);
    EXPECT_EQ(output[2], 24575);
    EXPECT_EQ(output[3], -32767);
}

TEST(WaveOutBackend, SetDeviceAcceptsDefaultDeviceBeforeInitialize) {
    WaveOut::WaveOutBackend backend;

    EXPECT_TRUE(backend.SetDevice("Default Device"));
    EXPECT_EQ(backend.m_deviceName, "Default Device");
    EXPECT_TRUE(backend.m_requestedDeviceName.empty());
}

TEST(WaveOutBackend, SetDeviceRejectsHotSwitchAfterOpen) {
    WaveOut::WaveOutBackend backend;
    backend.m_deviceName = "Default Device";
    backend.m_hWaveOut = reinterpret_cast<HWAVEOUT>(1);

    EXPECT_FALSE(backend.SetDevice("Some Other Device"));
    EXPECT_EQ(backend.m_deviceName, "Default Device");

    backend.m_hWaveOut = nullptr;
}

TEST(WaveOutBackend, FillPcm16BufferClampsSamplesToPcm16Range) {
    std::vector<float> input = {-2.0f, -0.5f, 0.5f, 2.0f};
    std::vector<int16_t> output(4, 123);

    WaveOut::WaveOutBackend::FillPcm16Buffer(output, input);

    ASSERT_EQ(output.size(), 4u);
    EXPECT_EQ(output[0], -32767);
    EXPECT_EQ(output[1], -16383);
    EXPECT_EQ(output[2], 16383);
    EXPECT_EQ(output[3], 32767);
}

#endif

} // namespace