/+
+            Copyright 2022 – 2024 Aya Partridge
+          Copyright 2018 - 2022 Michael D. Parker
+ Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+           http://www.boost.org/LICENSE_1_0.txt)
+/
module sdl_mixer;

import bindbc.sdl.config;
static if(bindSDLMixer):
import bindbc.sdl.codegen;

import sdl.audio: AUDIO_S16LSB, AUDIO_S16SYS, SDL_MIX_MAXVOLUME;
import sdl.error: SDL_GetError, SDL_SetError, SDL_ClearError, SDL_OutOfMemory;
import sdl.rwops: SDL_RWops, SDL_RWFromFile;
import sdl.stdinc: SDL_bool;
import sdl.version_: SDL_VERSIONNUM;

enum SDLMixerSupport: SDL_version{
	noLibrary   = SDL_version(0,0,0),
	badLibrary  = SDL_version(0,0,255),
	v2_0_0      = SDL_version(2,0,0),
	v2_0_1      = SDL_version(2,0,1),
	v2_0_2      = SDL_version(2,0,2),
	v2_0_4      = SDL_version(2,0,4),
	v2_6        = SDL_version(2,6,0),
	v2_8        = SDL_version(2,8,0),
	
	deprecated("Please use `v2_0_0` instead") sdlMixer200 = SDL_version(2,0,0),
	deprecated("Please use `v2_0_1` instead") sdlMixer201 = SDL_version(2,0,1),
	deprecated("Please use `v2_0_2` instead") sdlMixer202 = SDL_version(2,0,2),
	deprecated("Please use `v2_0_4` instead") sdlMixer204 = SDL_version(2,0,4),
	deprecated("Please use `v2_6` instead")   sdlMixer260 = SDL_version(2,6,0),
}

enum sdlMixerSupport = (){
	version(SDL_Mixer_2_8)      return SDLMixerSupport.v2_8;
	else version(SDL_Mixer_2_6) return SDLMixerSupport.v2_6;
	else version(SDL_Mixer_260) return SDLMixerSupport.v2_6; //NOTE: deprecated, remove this in bindbc-sdl 2.0
	else version(SDL_Mixer_204) return SDLMixerSupport.v2_0_4;
	else version(SDL_Mixer_202) return SDLMixerSupport.v2_0_2;
	else version(SDL_Mixer_201) return SDLMixerSupport.v2_0_1;
	else                        return SDLMixerSupport.v2_0_0;
}();

enum SDL_MIXER_MAJOR_VERSION = sdlMixerSupport.major;
enum SDL_MIXER_MINOR_VERSION = sdlMixerSupport.minor;
enum SDL_MIXER_PATCHLEVEL    = sdlMixerSupport.patch;

deprecated("Please use `SDL_MIXER_MAJOR_VERSION` instead") alias MIX_MAJOR_VERSION = SDL_MIXER_MAJOR_VERSION;
deprecated("Please use `SDL_MIXER_MINOR_VERSION` instead") alias MIX_MINOR_VERSION = SDL_MIXER_MINOR_VERSION;
deprecated("Please use `SDL_MIXER_PATCHLEVEL` instead")    alias MIX_PATCH_LEVEL   = SDL_MIXER_PATCHLEVEL;

pragma(inline, true) void SDL_MIXER_VERSION(SDL_version* x) nothrow @nogc pure @safe{
	x.major = SDL_MIXER_MAJOR_VERSION;
	x.minor = SDL_MIXER_MINOR_VERSION;
	x.patch = SDL_MIXER_PATCHLEVEL;
}

// These were implemented in SDL_mixer 2.0.2, but are fine for all versions.
deprecated("Please use SDL_MIXER_VERSION_ATLEAST or SDL_MIXER_VERSION instead")
	enum SDL_MIXER_COMPILEDVERSION = SDL_version(SDL_MIXER_MAJOR_VERSION, SDL_MIXER_MINOR_VERSION, SDL_MIXER_PATCHLEVEL);

pragma(inline, true) nothrow @nogc{
	bool SDL_MIXER_VERSION_ATLEAST(ubyte x, ubyte y, ubyte z){ return SDL_version(SDL_MIXER_MAJOR_VERSION, SDL_MIXER_MINOR_VERSION, SDL_MIXER_PATCHLEVEL) >= SDL_version(x, y, z); }
}
deprecated("Please use the non-template variant instead"){
	enum SDL_MIXER_VERSION_ATLEAST(ubyte x, ubyte y, ubyte z) = SDL_version(SDL_MIXER_MAJOR_VERSION, SDL_MIXER_MINOR_VERSION, SDL_MIXER_PATCHLEVEL) >= SDL_version(x, y, z);
}

alias Mix_InitFlags = int;
enum: Mix_InitFlags{
	MIX_INIT_FLAC        = 0x0000_0001,
	MIX_INIT_MOD         = 0x0000_0002,
	MIX_INIT_MP3         = 0x0000_0008,
	MIX_INIT_OGG         = 0x0000_0010,
}
static if(sdlMixerSupport < SDLMixerSupport.v2_0_2)
enum: Mix_InitFlags{
	MIX_INIT_MODPLUG     = 0x0000_0004,
	MIX_INIT_FLUIDSYNTH  = 0x0000_0020,
}
else //sdlMixerSupport >= SDLMixerSupport.v2_0_2
enum: Mix_InitFlags{
	MIX_INIT_MID         = 0x0000_0020,
}
static if(sdlMixerSupport >= SDLMixerSupport.v2_0_4)
enum: Mix_InitFlags{
	MIX_INIT_OPUS        = 0x0000_0040,
}

enum MIX_CHANNELS = 8;

enum MIX_DEFAULT_FREQUENCY = (){
	static if(sdlMixerSupport >= SDLMixerSupport.v2_6)
		return 44100;
	else
		return 22050;
}();

enum MIX_DEFAULT_FORMAT = (){
	static if(sdlMixerSupport >= SDLMixerSupport.v2_8){
		return AUDIO_S16SYS;
	}else{
		version(LittleEndian) return AUDIO_S16LSB;
		else                  return AUDIO_S16MSB;
	}
}();

enum MIX_DEFAULT_CHANNELS = 2;

alias MIX_MAX_VOLUME = SDL_MIX_MAXVOLUME;

struct Mix_Chunk{
	int allocated;
	ubyte* abuf;
	uint alen;
	ubyte volume;
}

alias Mix_Fading = int;
enum: Mix_Fading{
	MIX_NO_FADING,
	MIX_FADING_OUT,
	MIX_FADING_IN,
}

alias Mix_MusicType = int;
enum: Mix_MusicType{
	MUS_NONE            = 0,
	MUS_CMD             = 1,
	MUS_WAV             = 2,
	MUS_MOD             = 3,
	MUS_MID             = 4,
	MUS_OGG             = 5,
	MUS_MP3             = 6,
	
	MUS_FLAC            = 8,
}
static if(sdlMixerSupport < SDLMixerSupport.v2_0_2)
enum: Mix_MusicType{
	MUS_MP3_MAD         = 7,
	MUS_MODPLUG         = 9,
}
else //sdlMixerSupport >= SDLMixerSupport.v2_0_2
enum: Mix_MusicType{
	MUS_MP3_MAD_UNUSED  = 7,
	MUS_MODPLUG_UNUSED  = 9,
}
static if(sdlMixerSupport >= SDLMixerSupport.v2_0_4)
enum: Mix_MusicType{
	MUS_OPUS            = 10,
}
static if(sdlMixerSupport >= SDLMixerSupport.v2_8)
enum: Mix_MusicType{
	MUS_WAVPACK         = 11,
	MUS_GME             = 12,
}

struct Mix_Music;

enum MIX_CHANNEL_POST = -2;

enum MIX_EFFECTSMAXSPEED = "MIX_EFFECTSMAXSPEED";

extern(C) nothrow{
	alias Mix_EffectFunc_t = void function(int, void*, int, void*);
	alias Mix_EffectDone_t = void function(int, void*);
	
	//These aren't in SDL_mixer.h and are just here as a convenient and visible means to add the proper attributes to these callbacks.
	alias callbackVI = void function(int);
	alias callbackVPVPUbI = void function(void*, ubyte*, int);
	alias callbackV = void function();
	alias callbackIPCPV = int function(const(char*), void*);
}

alias Mix_SetError = SDL_SetError;

alias Mix_GetError = SDL_GetError;

alias Mix_ClearError = SDL_ClearError;

alias Mix_OutOfMemory = SDL_OutOfMemory;

static if(sdlMixerSupport < SDLMixerSupport.v2_6){
	pragma(inline, true) nothrow @nogc{
		Mix_Chunk* Mix_LoadWAV(const(char)* file){
			return Mix_LoadWAV_RW(SDL_RWFromFile(file, "rb"), 1);
		}
		
		int Mix_PlayChannel(int channel, Mix_Chunk* chunk, int loops){
			return Mix_PlayChannelTimed(channel, chunk, loops, -1);
		}
		
		int Mix_FadeInChannel(int channel, Mix_Chunk* chunk, int loops, int ms){
			return Mix_FadeInChannelTimed(channel, chunk, loops, ms, -1);
		}
	}
}

mixin(joinFnBinds((){
	FnBind[] ret = [
		{q{const(SDL_version)*}, q{Mix_Linked_Version}, q{}},
		{q{int}, q{Mix_Init}, q{int flags}},
		{q{void}, q{Mix_Quit}, q{}},
		{q{int}, q{Mix_OpenAudio}, q{int frequency, ushort format, int channels, int chunkSize}},
		{q{int}, q{Mix_AllocateChannels}, q{int numChans}},
		{q{int}, q{Mix_QuerySpec}, q{int* frequency, ushort* format, int* channels}},
		{q{Mix_Chunk*}, q{Mix_LoadWAV_RW}, q{SDL_RWops* src, int freeSrc}},
		{q{Mix_Music*}, q{Mix_LoadMUS}, q{const(char)* file}},
		{q{Mix_Music*}, q{Mix_LoadMUS_RW}, q{SDL_RWops* src, int freeSrc}},
		{q{Mix_Music*}, q{Mix_LoadMUSType_RW}, q{SDL_RWops* src, Mix_MusicType type, int freeSrc}},
		{q{Mix_Chunk*}, q{Mix_QuickLoad_WAV}, q{ubyte* mem}},
		{q{Mix_Chunk*}, q{Mix_QuickLoad_RAW}, q{ubyte* mem, uint len}},
		{q{void}, q{Mix_FreeChunk}, q{Mix_Chunk* chunk}},
		{q{void}, q{Mix_FreeMusic}, q{Mix_Music* music}},
		{q{int}, q{Mix_GetNumChunkDecoders}, q{}},
		{q{const(char)*}, q{Mix_GetChunkDecoder}, q{int index}},
		{q{int}, q{Mix_GetNumMusicDecoders}, q{}},
		{q{const(char)*}, q{Mix_GetMusicDecoder}, q{int index}},
		{q{Mix_MusicType}, q{Mix_GetMusicType}, q{const(Mix_Music)* music}},
		{q{void}, q{Mix_SetPostMix}, q{callbackVPVPUbI mixFunc, void* arg}},
		{q{void}, q{Mix_HookMusic}, q{callbackVPVPUbI mixFunc, void* arg}},
		{q{void}, q{Mix_HookMusicFinished}, q{callbackV musicFinished}},
		{q{void*}, q{Mix_GetMusicHookData}, q{}},
		{q{void}, q{Mix_ChannelFinished}, q{callbackVI channelFinished}},
		{q{int}, q{Mix_RegisterEffect}, q{int chan, Mix_EffectFunc_t f, Mix_EffectDone_t d, void* arg}},
		{q{int}, q{Mix_UnregisterEffect}, q{int channel, Mix_EffectFunc_t f}},
		{q{int}, q{Mix_UnregisterAllEffects}, q{int channel}},
		{q{int}, q{Mix_SetPanning}, q{int channel, ubyte left, ubyte right}},
		{q{int}, q{Mix_SetPosition}, q{int channel, short angle, ubyte distance}},
		{q{int}, q{Mix_SetDistance}, q{int channel, ubyte distance}},
		{q{int}, q{Mix_SetReverseStereo}, q{int channel, int flip}},
		{q{int}, q{Mix_ReserveChannels}, q{int num}},
		{q{int}, q{Mix_GroupChannel}, q{int which, int tag}},
		{q{int}, q{Mix_GroupChannels}, q{int from, int to, int tag}},
		{q{int}, q{Mix_GroupAvailable}, q{int tag}},
		{q{int}, q{Mix_GroupCount}, q{int tag}},
		{q{int}, q{Mix_GroupOldest}, q{int tag}},
		{q{int}, q{Mix_GroupNewer}, q{int tag}},
		{q{int}, q{Mix_PlayChannelTimed}, q{int channel, Mix_Chunk* chunk, int loops, int ticks}},
		{q{int}, q{Mix_PlayMusic}, q{Mix_Music* music, int loops}},
		{q{int}, q{Mix_FadeInMusic}, q{Mix_Music* music, int loops, int ms}},
		{q{int}, q{Mix_FadeInMusicPos}, q{Mix_Music* music, int loops, int ms, double position}},
		{q{int}, q{Mix_FadeInChannelTimed}, q{int channel, Mix_Chunk* chunk, int loops, int ms, int ticks}},
		{q{int}, q{Mix_Volume}, q{int channel, int volume}},
		{q{int}, q{Mix_VolumeChunk}, q{Mix_Chunk* chunk, int volume}},
		{q{int}, q{Mix_VolumeMusic}, q{int volume}},
		{q{int}, q{Mix_HaltChannel}, q{int channel}},
		{q{int}, q{Mix_HaltGroup}, q{int tag}},
		{q{int}, q{Mix_HaltMusic}, q{}},
		{q{int}, q{Mix_ExpireChannel}, q{int channel, int ticks}},
		{q{int}, q{Mix_FadeOutChannel}, q{int which, int ms}},
		{q{int}, q{Mix_FadeOutGroup}, q{int tag, int ms}},
		{q{int}, q{Mix_FadeOutMusic}, q{int ms}},
		{q{Mix_Fading}, q{Mix_FadingMusic}, q{}},
		{q{Mix_Fading}, q{Mix_FadingChannel}, q{int which}},
		{q{void}, q{Mix_Pause}, q{int channel}},
		{q{void}, q{Mix_Resume}, q{int channel}},
		{q{int}, q{Mix_Paused}, q{int channel}},
		{q{void}, q{Mix_PauseMusic}, q{}},
		{q{void}, q{Mix_ResumeMusic}, q{}},
		{q{void}, q{Mix_RewindMusic}, q{}},
		{q{int}, q{Mix_PausedMusic}, q{}},
		{q{int}, q{Mix_SetMusicPosition}, q{double position}},
		{q{int}, q{Mix_Playing}, q{int channel}},
		{q{int}, q{Mix_PlayingMusic}, q{}},
		{q{int}, q{Mix_SetMusicCMD}, q{const(char)* command}},
		{q{int}, q{Mix_SetSynchroValue}, q{int value}},
		{q{int}, q{Mix_GetSynchroValue}, q{}},
		{q{int}, q{Mix_SetSoundFonts}, q{const(char)* paths}},
		{q{const(char)*}, q{Mix_GetSoundFonts}, q{}},
		{q{int}, q{Mix_EachSoundFont}, q{callbackIPCPV function_, void* data}},
		{q{Mix_Chunk*}, q{Mix_GetChunk}, q{int channel}},
		{q{void}, q{Mix_CloseAudio}, q{}},
	];
	if(sdlMixerSupport >= SDLMixerSupport.v2_0_2){
		FnBind[] add = [
			{q{int}, q{Mix_OpenAudioDevice}, q{int frequency, ushort format, int channels, int chunkSize, const(char)* device, int allowedChanges}},
			{q{SDL_bool}, q{Mix_HasChunkDecoder}, q{const(char)* name}},
			//[q{SDL_bool}, q{Mix_HasMusicDecoder}, q{const(char)*}], //Declared in SDL_mixer.h, but not implemented
		];
		ret ~= add;
	}
	if(sdlMixerSupport >= SDLMixerSupport.v2_6){
		FnBind[] add = [
			{q{Mix_Chunk*}, q{Mix_LoadWAV}, q{const(char)* file}},
			{q{int}, q{Mix_PlayChannel}, q{int channel, Mix_Chunk* chunk, int loops}},
			{q{int}, q{Mix_FadeInChannel}, q{int channel, Mix_Chunk* chunk, int loops, int ms}},
			{q{SDL_bool}, q{Mix_HasMusicDecoder}, q{const(char)* name}},
			{q{const(char)*}, q{Mix_GetMusicTitle}, q{const(Mix_Music)* music}},
			{q{const(char)*}, q{Mix_GetMusicTitleTag}, q{const(Mix_Music)* music}},
			{q{const(char)*}, q{Mix_GetMusicArtistTag}, q{const(Mix_Music)* music}},
			{q{const(char)*}, q{Mix_GetMusicAlbumTag}, q{const(Mix_Music)* music}},
			{q{const(char)*}, q{Mix_GetMusicCopyrightTag}, q{const(Mix_Music)* music}},
			{q{int}, q{Mix_GetMusicVolume}, q{Mix_Music* music}},
			{q{int}, q{Mix_MasterVolume}, q{int volume}},
			{q{int}, q{Mix_ModMusicJumpToOrder}, q{int order}},
			{q{double}, q{Mix_GetMusicPosition}, q{Mix_Music* music}},
			{q{double}, q{Mix_MusicDuration}, q{Mix_Music* music}},
			{q{double}, q{Mix_GetMusicLoopStartTime}, q{Mix_Music* music}},
			{q{double}, q{Mix_GetMusicLoopEndTime}, q{Mix_Music* music}},
			{q{double}, q{Mix_GetMusicLoopLengthTime}, q{Mix_Music* music}},
			{q{int}, q{Mix_SetTimidityCfg}, q{const(char)* path}},
			{q{const(char)*}, q{Mix_GetTimidityCfg}, q{}},
		];
		ret ~= add;
	}
	if(sdlMixerSupport >= SDLMixerSupport.v2_8){
		FnBind[] add = [
			{q{void}, q{Mix_PauseAudio}, q{int pauseOn}},
			{q{int}, q{Mix_StartTrack}, q{Mix_Music* music, int track}},
			{q{int}, q{Mix_GetNumTracks}, q{Mix_Music* music}},
		];
		ret ~= add;
	}
	return ret;
}()));

static if(!staticBinding):
import bindbc.loader;

private{
	SharedLib lib;
	SDLMixerSupport loadedVersion;
	enum libNamesCT = (){
		version(Windows){
			return [
				`SDL2_mixer.dll`,
			];
		}else version(OSX){
			return [
				`libSDL2_mixer.dylib`,
				`/opt/homebrew/lib/libSDL2_mixer.dylib`,
				`SDL2_mixer`,
				`/Library/Frameworks/SDL2_mixer.framework/SDL2_mixer`,
				`/System/Library/Frameworks/SDL2_mixer.framework/SDL2_mixer`,
			];
		}else version(Posix){
			return [
				`libSDL2_mixer.so`,
				`libSDL2-2.0_mixer.so`,
				`libSDL2-2.0_mixer.so.0`,
			];
		}else static assert(0, "BindBC-SDL_mixer does not have library search paths set up for this platform");
	}();
}

nothrow @nogc:
deprecated("Please use `Mix_Linked_Version` instead")
	SDLMixerSupport loadedSDLMixerVersion(){ return loadedVersion; }

mixin(bindbc.sdl.codegen.makeDynloadFns("Mixer", [__MODULE__]));