#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, MasterVolumeIsClampedToValidRange) {
    WaveOut::WaveOutBackend backend;

    backend.SetMasterVolume(1.5f);
    EXPECT_FLOAT_EQ(backend.GetMasterVolume(), 1.0f);

    backend.SetMasterVolume(-0.5f);
    EXPECT_FLOAT_EQ(backend.GetMasterVolume(), 0.0f);
}

TEST(WaveOutBackend, ProcessAudioCopiesOnlyRequestedSamplesIntoPendingMixBuffer) {
    WaveOut::WaveOutBackend backend;
    backend.m_pendingMixBuffer.assign(8, 1.0f);

    float input[] = {0.25f, -0.5f, 0.75f, -1.0f};
    backend.ProcessAudio(input, 2, 2, 48000);

    ASSERT_EQ(backend.m_pendingMixBuffer.size(), 8u);
    EXPECT_TRUE(backend.m_hasPendingMix);
    EXPECT_FLOAT_EQ(backend.m_pendingMixBuffer[0], 0.25f);
    EXPECT_FLOAT_EQ(backend.m_pendingMixBuffer[1], -0.5f);
    EXPECT_FLOAT_EQ(backend.m_pendingMixBuffer[2], 0.75f);
    EXPECT_FLOAT_EQ(backend.m_pendingMixBuffer[3], -1.0f);
    EXPECT_FLOAT_EQ(backend.m_pendingMixBuffer[4], 0.0f);
    EXPECT_FLOAT_EQ(backend.m_pendingMixBuffer[5], 0.0f);
    EXPECT_FLOAT_EQ(backend.m_pendingMixBuffer[6], 0.0f);
    EXPECT_FLOAT_EQ(backend.m_pendingMixBuffer[7], 0.0f);
}

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, FillPcm16BufferAppliesVolumeClampAndMute) {
    std::vector<float> input = {-2.0f, -0.5f, 0.5f, 2.0f};
    std::vector<int16_t> output(4, 123);

    WaveOut::WaveOutBackend::FillPcm16Buffer(output, input, 0.5f, false);

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

    WaveOut::WaveOutBackend::FillPcm16Buffer(output, input, 1.0f, true);

    EXPECT_EQ(output[0], 0);
    EXPECT_EQ(output[1], 0);
    EXPECT_EQ(output[2], 0);
    EXPECT_EQ(output[3], 0);
}

#endif

} // namespace