// -----------------------------------------------------------------------------------------------
// Step 1: prepare the rf::Config
// -----------------------------------------------------------------------------------------------

void LockAudioDevice()
{
    // Implementation specific way of locking your audio device.
}

void UnlockAudioDevice()
{
    // Implementation specific way of unlocking your audio device.
}

// The buffer size. This is the number of audio frames to be processed in an audio callback.
const int bufferSize = 1024;
// Currently, RedFish only offically supports 2 channels.
const int numChannels = 2;
// The sample rate of your project.
const int sampleRate = 48000;

rf::Config config(bufferSize, numChannles, sampleRate, LockAudioDevice, UnlockAudioDevice);

// If you want, you can provide a custom allocator and deallocator.
config.m_onAllocate = [](size_t numBytes, const char* name, int alignment) {
    void* data = _aligned_malloc(numBytes, alignment);
    return data;
};
config.m_onDeallocate = [](void* data) {
    _aligned_free(data);
};

// -----------------------------------------------------------------------------------------------
// Step 2: Create
// -----------------------------------------------------------------------------------------------

rf::Context* context = new rf::Context(config);
rf::AudioCallback* callback = new rf::AudioCallback(context);

// If you want to use the editor, allocate one!
rf::Editor* editor = new rf::Editor(context);

// -----------------------------------------------------------------------------------------------
// Step 3: Update
// -----------------------------------------------------------------------------------------------

// Update rf::Context in your application's update/ticking function.
context->Update();

// Have an editor? Update it after the context.
editor->Update();

// Update rf::AudioCallback in your application's audio callback
// buffer is a float* that RedFish will fill with float samples to play this callback.
// bufferSize is how many audio frames are required this callback.
callback->Update(buffer, bufferSize);

// Load
rf::AssetSystem* assetSystem = m_context->GetAssetSystem();
const rf::AudioHandle audioHandle = assetSystem->Load("../testbench/testdata/a2-tile-land-001.wav");

// Unload
assetSystem->Unload(audioHandle);

rf::System* mixerSystem = context->GetMixerSystem();
rf::MixGroup* mixGroupSFX = mixerSystem->CreateMixGroup();

rf::SoundEffect sfx = rf::SoundEffect(context);
sfx.SetMixGroup(mixGroupSFX);
sfx.AddVariation(audioHandle);
sfx.Play();

// Load some audio
rf::AssetSystem* assetSystem = m_context->GetAssetSystem();
const rf::AudioHandle audioHandle = assetSystem->Load("BasicSong_Intro.flac");

// Create a music cue
rf::CueParameters cueParams;
cueParams.m_meter = rf::Meter(4, 4);
cueParams.m_tempo = 130.0f;
cueParams.m_name = "BasicSong_Intro";
cueParams.AddLayer(audioHandle, mixGroupMusic);
rf::Cue* cue = musicSytem->CreateCue(cueParams);

// Create a transition to play the cue
rf::TransitionParameters transParams;
transParams.m_cue = cue;
transParams.m_name = "To_BasicSong_Intro";
rf::Transition* transition = musicSytem->CreateTransition(transParams);

// Play the transistion
rf::MusicSystem* musicSystem = context->GetMusicSystem();
musicSystem->Play(transition);

m_context->Deserialize("redfish.json");

// After deserialization, associate mix groupss with mix group pointers.
rf::MixerSystem* mixerSystem = context->GetMixerSystem();
rf::MixGroup* mixGroupEntities = mixerSystem->GetMixGroup("Entities");
rf::MixGroup* mixGroupAmbience = mixerSystem->GetMixGroup("Ambience");
rf::MixGroup* mixGroupReverb = mixerSystem->GetMixGroup("Reverb");
rf::MixGroup* mixGroupDelay = mixerSystem->GetMixGroup("Delay");
rf::MixGroup* mixGroupLeads = mixerSystem->GetMixGroup("Leads");
rf::MixGroup* mixGroupBass = mixerSystem->GetMixGroup("Bass");
rf::MixGroup* mixGroupDrums = mixerSystem->GetMixGroup("Drums");
rf::MixGroup* mixGroupMusic = mixerSystem->GetMixGroup("Music");
rf::MixGroup* mixGroupSounds = mixerSystem->GetMixGroup("Sounds");
rf::MixGroup* mixGroupMaster = mixerSystem->GetMasterMixGroup();

// After deserialization, associate plugins with plugin pointers.
rf::IIR2HighpassFilterPlugin* iir2Highpass = mixGroupEntities->GetPlugin<rf::IIR2HighpassFilterPlugin>(0);
rf::IIR2LowpassFilterPlugin* iir2Lowpass = mixGroupEntities->GetPlugin<rf::IIR2LowpassFilterPlugin>(1);
rf::CompressorPlugin* compressor = mixGroupEntities->GetPlugin<rf::CompressorPlugin>(2);
rf::PositioningPlugin* positioning = mixGroupEntities->GetPlugin<rf::PositioningPlugin>(3);
rf::GainPlugin* = gain = mixGroupAmbience->GetPlugin<rf::GainPlugin>(0);
rf::PanPlugin* pan = mixGroupAmbience->GetPlugin<rf::PanPlugin>(1);
rf::ButterworthHighpassFilterPlugin* bwHighpass = mixGroupAmbience->GetPlugin<rf::ButterworthHighpassFilterPlugin>(2);
rf::ButterworthLowpassFilterPlugin* bwLowpass = mixGroupAmbience->GetPlugin<rf::ButterworthLowpassFilterPlugin>(3);
rf::DelayPlugin* = delay = mixGroupDelay->GetPlugin<rf::DelayPlugin>(0);
rf::LimiterPlugin* limiter = mixGroupMaster->GetPlugin<rf::LimiterPlugin>(0);

// After deserialization, create a convolver. At this time, convolvers do not support serialization.
rf::ConvolverPlugin* convolverReverb = m_mixGroupReverb->CreatePlugin<rf::ConvolverPlugin>();