#include <campello_audio/audio_engine.hpp>

using namespace systems::leal::campello_audio;

AudioEngine engine;

AudioEngineDescriptor desc;
desc.sampleRate = 44100;
desc.maxVoices  = 32;
desc.channels   = 2;

engine.init(desc);
// ... use engine ...
engine.deinit();

#include <campello_audio/wav_source.hpp>

WavSource shot;
shot.load("assets/gunshot.wav");

engine.play(shot);   // returns SoundHandle — safe to ignore

WavSource music;
music.load("assets/theme.wav");

PlayDescriptor pd;
pd.looping = true;
pd.volume  = 0.8f;

SoundHandle h = engine.play(music, pd);

// Later...
engine.fadeVolume(h, 0.0f, 2.0);  // fade out over 2 seconds
engine.stop(h);

#include <campello_audio/ogg_source.hpp>
#include <campello_audio/mp3_source.hpp>

OggSource ogg;
ogg.load("assets/ambient.ogg");
engine.play(ogg);

Mp3Source mp3;
mp3.load("assets/track.mp3");
engine.play(mp3);

#include <campello_audio/tone_source.hpp>

ToneSource beep(WaveForm::Sine, 440.0f);
SoundHandle h = engine.play(beep);
engine.fadeVolume(h, 0.0f, 0.3);   // short beep

#include <campello_audio/audio_bus.hpp>
#include <campello_audio/reverb_filter.hpp>

AudioBus sfxBus;
auto reverb = std::make_shared<ReverbFilter>(0.7f, 0.4f);
sfxBus.addFilter(reverb, 0);

// Play the bus into the main mix
engine.play(sfxBus);

// Route individual sounds through the bus
WavSource explosion;
explosion.load("explosion.wav");
sfxBus.play(explosion);

#include <campello_audio/low_pass_filter.hpp>

WavSource rain;
rain.load("rain.wav");

auto lpf = std::make_shared<LowPassFilter>(3000.0f, 0.707f);
rain.addFilter(lpf, 0);

SoundHandle h = engine.play(rain);

// Smoothly sweep the cutoff (underwater effect)
lpf->fadeParam(LowPassFilter::PARAM_CUTOFF, 500.0f, 1.5);

// Remove filter
rain.removeFilter(0);

#include <campello_audio/audio_stream.hpp>

AudioStream music;
music.open("assets/music/theme.ogg");
music.setLooping(true);
engine.play(music);

#include <campello_audio/random_source.hpp>

RandomSource gunshot;
for (auto& p : {"shot1.wav", "shot2.wav", "shot3.wav"}) {
    auto v = std::make_shared<WavSource>();
    v->load(p);
    gunshot.addVariant(v);
}
gunshot.setPitchVariation(2.0f);   // ±2 semitones
gunshot.setVolumeVariation(2.0f);  // ±2 dB
gunshot.setAvoidRepeat(true);

engine.play(gunshot);  // picks a different variant each call

#include <campello_audio/compressor_filter.hpp>
#include <campello_audio/limiter_filter.hpp>

// SFX bus compressor
AudioBus sfxBus;
auto comp = std::make_shared<CompressorFilter>(-12.0f, 4.0f, 5.0f, 50.0f);
sfxBus.addFilter(comp, 0);

// Master output limiter (on the main mix bus)
AudioBus masterBus;
auto limiter = std::make_shared<LimiterFilter>(-0.3f, 5.0f, 50.0f);
masterBus.addFilter(limiter, 0);

// Dialogue bus triggers ducking of music bus
engine.setSidechain(&dialogueBus, &musicBus,
                    -12.0f,   // duck by 12 dB
                    0.05f,    // 50 ms attack
                    0.5f);    // 500 ms release

auto shot = std::make_shared<WavSource>();
shot->loadAsync("gunshot.wav", [&](bool ok) {
    // Called on the main thread during engine.tick()
    if (ok) engine.play(*shot);
});

// In your game loop:
engine.tick();  // drains the callback queue

#include <campello_audio/audio_parameter.hpp>

// Register a "speed" parameter ranging 0–200 km/h
auto speed = std::make_shared<AudioParameter>("speed", 0.0f, 200.0f);
engine.registerParameter(speed);

// Bind it: engine pitch 0.5× at rest, 2.0× at max speed (exponential curve)
engineSound.bindParameter("speed", AudioSourceProperty::Pitch,
                          CurveType::Exponential, 0.5f, 2.0f);

// Drive it from game code each frame — no audio code required
engine.setParameter("speed", vehicle.getSpeed());

#include <campello_audio/audio_snapshot.hpp>

auto underwater = std::make_shared<AudioSnapshot>("underwater");
underwater->setGlobalVolume(0.6f);
underwater->setBusFilter(&sfxBus, std::make_shared<LowPassFilter>(400.0f), 0);
engine.registerSnapshot(underwater);

// Player dives
engine.applySnapshot("underwater", 1.5);   // blend in over 1.5 s

// Player surfaces
engine.revertSnapshot(1.0);                // blend out over 1.0 s

#include <campello_audio/music_track.hpp>

auto track = std::make_shared<MusicTrack>();
track->setBpm(120.0f);
track->setTimeSignature(4, 4);

auto explore = std::make_shared<AudioStream>(); explore->open("explore.ogg");
auto combat  = std::make_shared<AudioStream>(); combat->open("combat.ogg");

track->addSection(explore, "explore");
track->addSection(combat,  "combat");
track->addTransition("explore", "combat", TransitionRule::OnBar,  0.5);
track->addTransition("combat",  "explore",TransitionRule::OnBar,  1.0);

engine.play(*track);

// When the player enters combat — transition fires at next bar boundary
engine.requestMusicTransition("combat");

// Call once per frame with the current listener state
ListenerDescriptor listener;
listener.position = {camX, camY, camZ};
listener.forward  = {fwdX, fwdY, fwdZ};
listener.up       = {0.0f, 1.0f, 0.0f};
engine.set3dListenerParameters(listener);

// Play a 3D-positioned sound
PlayDescriptor pd3d;
pd3d.enable3d    = true;
pd3d.position    = {10.0f, 0.0f, -5.0f};
pd3d.minDistance = 1.0f;
pd3d.maxDistance = 50.0f;

WavSource gunshot;
gunshot.load("gunshot.wav");
SoundHandle h = engine.play(gunshot, pd3d);

// Update source position each frame
engine.set3dSourceParameters(h, newX, newY, newZ);

// Apply 3D calculations — call once per frame before audio processing
engine.update3d();

// Smooth volume fade
engine.fadeVolume(h, 0.0f, 2.0);

// Pan sweep
engine.fadePan(h, -1.0f, 1.0);

// LFO volume tremolo
engine.oscillateVolume(h, 0.5f, 1.0f, 0.25);   // 4 Hz tremolo

AudioEngineDescriptor desc;
desc.visualization = true;
engine.init(desc);

// Each frame
uint32_t count;
const float* samples = engine.getVisualizationData(count);
// samples contains the last mixed buffer (count floats)