/*****************************************************************************
The Dark Mod GPL Source Code

This file is part of the The Dark Mod Source Code, originally based
on the Doom 3 GPL Source Code as published in 2011.

The Dark Mod Source Code is free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of the License,
or (at your option) any later version. For details, see LICENSE.TXT.

Project: The Dark Mod (http://www.thedarkmod.com/)

******************************************************************************/
#include "precompiled.h"
#pragma hdrstop



#include "snd_local.h"
#include "../idlib/math/Math.h"
#include "snd_efxpresets.h"

#define mB_to_gain(millibels, property) \
	_mB_to_gain(millibels,AL_EAXREVERB_MIN_ ## property, AL_EAXREVERB_MAX_ ## property)

static inline ALfloat _mB_to_gain(ALfloat millibels, ALfloat min, ALfloat max) {
	return idMath::ClampFloat(min, max, idMath::Pow(10.0f, millibels / 2000.0f));
}

idSoundEffect::idSoundEffect() :
effect(0) {
}

idSoundEffect::~idSoundEffect() {
	if (soundSystemLocal.alIsEffect(effect))
		soundSystemLocal.alDeleteEffects(1, &effect);
}

bool idSoundEffect::alloc() {
	alGetError();

	ALenum e;

	soundSystemLocal.alGenEffects(1, &effect);
	e = alGetError();
	if (e != AL_NO_ERROR) {
		common->Warning("idSoundEffect::alloc: alGenEffects failed: 0x%x", e);
		return false;
	}

	soundSystemLocal.alEffecti(effect, AL_EFFECT_TYPE, AL_EFFECT_EAXREVERB);
	e = alGetError();
	if (e != AL_NO_ERROR) {
		common->Warning("idSoundEffect::alloc: alEffecti failed: 0x%x", e);
		return false;
	}

	return true;
}

/*
===============
idEFXFile::idEFXFile
===============
*/
idEFXFile::idEFXFile( void ) {
	isAfterReload = false;
}

/*
===============
idEFXFile::Clear
===============
*/
void idEFXFile::Clear( void ) {
	effects.DeleteContents( true );
}

/*
===============
idEFXFile::~idEFXFile
===============
*/
idEFXFile::~idEFXFile( void ) {
	Clear();
}

/*
===============
idEFXFile::FindEffect
===============
*/
bool idEFXFile::FindEffect(idStr &name, ALuint *effect) {
	int i;

	for (i = 0; i < effects.Num(); i++) {
		if (effects[i]->name.Icmp(name) == 0) {
			*effect = effects[i]->effect;
			return true;
		}
	}

	return false;
}

#define efxi(param, value)													\
	do {																	\
		ALint _v = value;													\
		EFXprintf("alEffecti(" #param ", %d)\n", _v);						\
		soundSystemLocal.alEffecti(effect->effect, param, _v);				\
		err = alGetError();													\
		if (err != AL_NO_ERROR)												\
			common->Warning("alEffecti(" # param ", %d) "					\
							"failed: 0x%x", _v, err);						\
		} while (false)

#define efxf(param, value)													\
	do {																	\
		ALfloat _v = value;													\
		EFXprintf("alEffectf(" #param ", %.3f)\n", _v);						\
		soundSystemLocal.alEffectf(effect->effect, param, _v);				\
		err = alGetError();													\
		if (err != AL_NO_ERROR)												\
			common->Warning("alEffectf(" # param ", %.3f) "					\
							"failed: 0x%x", _v, err);						\
		} while (false)

#define efxfv(param, value0, value1, value2)								\
	do {																	\
		ALfloat _v[3];														\
		_v[0] = value0;														\
		_v[1] = value1;														\
		_v[2] = value2;														\
		EFXprintf("alEffectfv(" #param ", %.3f, %.3f, %.3f)\n",				\
					_v[0], _v[1], _v[2]);									\
		soundSystemLocal.alEffectfv(effect->effect, param, _v);				\
		err = alGetError();													\
		if (err != AL_NO_ERROR)												\
			common->Warning("alEffectfv(" # param ", %.3f, %.3f, %.3f) "	\
							"failed: 0x%x",	_v[0], _v[1], _v[2], err);		\
		} while (false)

/*
===============
idEFXFile::ReadEffectLegacy

Reads EAX effect in Doom 3 original format.
It is then converted to EFX parameters.
===============
*/
bool idEFXFile::ReadEffectLegacy(idLexer &src, idSoundEffect *effect) {
	idToken name, token;

	if ( !src.ReadToken( &token ) )
		return false;

	// reverb effect
	if ( token != "reverb" ) {
		// other effect (not supported at the moment)
		src.Error( "idEFXFile::ReadEffect: Unknown effect definition" );

		return false;
	}

	src.ReadTokenOnLine( &token );
	name = token;

	if ( !src.ReadToken( &token ) )
		return false;

	if ( token != "{" ) {
		src.Error( "idEFXFile::ReadEffect: { not found, found %s", token.c_str() );
		return false;
	}

	ALenum err;
	alGetError();
	common->Printf("Loading EAX effect '%s' (#%u)\n", name.c_str(), effect->effect);

	do {
		if ( !src.ReadToken( &token ) ) {
			src.Error( "idEFXFile::ReadEffect: EOF without closing brace" );
			return false;
		}

		if ( token == "}" ) {
			effect->name = name;
			break;
		}

		if ( token == "environment" ) {
			// <+KittyCat> the "environment" token should be ignored (efx has nothing equatable to it)
			src.ParseInt();
		} else if ( token == "environment size" ) {
			float size = src.ParseFloat();
			efxf(AL_EAXREVERB_DENSITY, (size < 2.0f) ? (size - 1.0f) : 1.0f);
		} else if ( token == "environment diffusion" ) {
			efxf(AL_EAXREVERB_DIFFUSION, src.ParseFloat());
		} else if ( token == "room" ) {
			efxf(AL_EAXREVERB_GAIN, mB_to_gain(src.ParseInt(), GAIN));
		} else if ( token == "room hf" ) {
			efxf(AL_EAXREVERB_GAINHF, mB_to_gain(src.ParseInt(), GAINHF));
		} else if ( token == "room lf" ) {
			efxf(AL_EAXREVERB_GAINLF, mB_to_gain(src.ParseInt(), GAINLF));
		} else if ( token == "decay time" ) {
			efxf(AL_EAXREVERB_DECAY_TIME, src.ParseFloat());
		} else if ( token == "decay hf ratio" ) {
			efxf(AL_EAXREVERB_DECAY_HFRATIO, src.ParseFloat());
		} else if ( token == "decay lf ratio" ) {
			efxf(AL_EAXREVERB_DECAY_LFRATIO, src.ParseFloat());
		} else if ( token == "reflections" ) {
			efxf(AL_EAXREVERB_REFLECTIONS_GAIN, mB_to_gain(src.ParseInt(), REFLECTIONS_GAIN));
		} else if ( token == "reflections delay" ) {
			efxf(AL_EAXREVERB_REFLECTIONS_DELAY, src.ParseFloat());
		} else if ( token == "reflections pan" ) {
			efxfv(AL_EAXREVERB_REFLECTIONS_PAN, src.ParseFloat(), src.ParseFloat(), src.ParseFloat());
		} else if ( token == "reverb" ) {
			efxf(AL_EAXREVERB_LATE_REVERB_GAIN, mB_to_gain(src.ParseInt(), LATE_REVERB_GAIN));
		} else if ( token == "reverb delay" ) {
			efxf(AL_EAXREVERB_LATE_REVERB_DELAY, src.ParseFloat());
		} else if ( token == "reverb pan" ) {
			efxfv(AL_EAXREVERB_LATE_REVERB_PAN, src.ParseFloat(), src.ParseFloat(), src.ParseFloat());
		} else if ( token == "echo time" ) {
			efxf(AL_EAXREVERB_ECHO_TIME, src.ParseFloat());
		} else if ( token == "echo depth" ) {
			efxf(AL_EAXREVERB_ECHO_DEPTH, src.ParseFloat());
		} else if ( token == "modulation time" ) {
			efxf(AL_EAXREVERB_MODULATION_TIME, src.ParseFloat());
		} else if ( token == "modulation depth" ) {
			efxf(AL_EAXREVERB_MODULATION_DEPTH, src.ParseFloat());
		} else if ( token == "air absorption hf" ) {
			efxf(AL_EAXREVERB_AIR_ABSORPTION_GAINHF, mB_to_gain(src.ParseFloat(), AIR_ABSORPTION_GAINHF));
		} else if ( token == "hf reference" ) {
			efxf(AL_EAXREVERB_HFREFERENCE, src.ParseFloat());
		} else if ( token == "lf reference" ) {
			efxf(AL_EAXREVERB_LFREFERENCE, src.ParseFloat());
		} else if ( token == "room rolloff factor" ) {
			efxf(AL_EAXREVERB_ROOM_ROLLOFF_FACTOR, src.ParseFloat());
		} else if ( token == "flags" ) {
			src.ReadTokenOnLine( &token );
			unsigned int flags = token.GetUnsignedIntValue();

			efxi(AL_EAXREVERB_DECAY_HFLIMIT, (flags & 0x20) ? AL_TRUE : AL_FALSE);
			// the other SCALE flags have no equivalent in efx
		} else {
			src.ReadTokenOnLine( &token );
			src.Error( "idEFXFile::ReadEffect: Invalid parameter in reverb definition" );
		}
	} while ( 1 );

	return true;
}

bool idEFXFile::ReadEffectOpenAL(idLexer &src, idSoundEffect *effect) {
	idToken token;

	if (!src.ReadToken(&token))
		return false;	// no more effects
	src.UnreadToken(&token);

	//location name
	if (!src.ExpectTokenString("eaxreverb"))
		return false;
	src.ReadTokenOnLine(&token);
	idStr name = token;
	if (!src.ExpectTokenString("{"))
		return false;

	ALenum err;
	alGetError();
	common->Printf("Loading EFX effect for location '%s' (#%u)\n", name.c_str(), effect->effect);

	while (1) {
		if (!src.ReadToken(&token)) {
			src.Error( "idEFXFile::ReadEffect: EOF without closing brace" );
			return false;
		}
		if ( token == "}" ) {
			effect->name = name;
			break;
		}

		token.ToUpper();

		if ( token == "PRESET" ) {
			if (!src.ExpectAnyToken(&token))
				return false;
			token.ToUpper();

			const EFXEAXREVERBPROPERTIES *props = NULL;
			int k = 0;
			for (k = 0; efxPresets[k].name[0]; k++)
				if (efxPresets[k].name == token) {
					props = &efxPresets[k].props;
					break;
				}
			if (!props && (token.type == TT_NUMBER)) {
				int idx = token.GetIntValue();
				if (idx >= 0 && idx < k)
					props = &efxPresets[idx].props;
			}
			if (!props) {
				src.Error("idEFXFile::ReadEffect: Unknown preset name %s", token.c_str());
				return false;
			}

			efxf(AL_EAXREVERB_DENSITY, props->flDensity);
			efxf(AL_EAXREVERB_DIFFUSION, props->flDiffusion);
			efxf(AL_EAXREVERB_GAIN, props->flGain);
			efxf(AL_EAXREVERB_GAINHF, props->flGainHF);
			efxf(AL_EAXREVERB_GAINLF, props->flGainLF);
			efxf(AL_EAXREVERB_DECAY_TIME, props->flDecayTime);
			efxf(AL_EAXREVERB_DECAY_HFRATIO, props->flDecayHFRatio);
			efxf(AL_EAXREVERB_DECAY_LFRATIO, props->flDecayLFRatio);
			efxf(AL_EAXREVERB_REFLECTIONS_GAIN, props->flReflectionsGain);
			efxf(AL_EAXREVERB_REFLECTIONS_DELAY, props->flReflectionsDelay);
			efxfv(AL_EAXREVERB_REFLECTIONS_PAN, props->flReflectionsPan[0], props->flReflectionsPan[1], props->flReflectionsPan[2]);
			efxf(AL_EAXREVERB_LATE_REVERB_GAIN, props->flLateReverbGain);
			efxf(AL_EAXREVERB_LATE_REVERB_DELAY, props->flLateReverbDelay);
			efxfv(AL_EAXREVERB_LATE_REVERB_PAN, props->flLateReverbPan[0], props->flLateReverbPan[1], props->flLateReverbPan[2]);
			efxf(AL_EAXREVERB_ECHO_TIME, props->flEchoTime);
			efxf(AL_EAXREVERB_ECHO_DEPTH, props->flEchoDepth);
			efxf(AL_EAXREVERB_MODULATION_TIME, props->flModulationTime);
			efxf(AL_EAXREVERB_MODULATION_DEPTH, props->flModulationDepth);
			efxf(AL_EAXREVERB_AIR_ABSORPTION_GAINHF, props->flAirAbsorptionGainHF);
			efxf(AL_EAXREVERB_HFREFERENCE, props->flHFReference);
			efxf(AL_EAXREVERB_LFREFERENCE, props->flLFReference);
			efxf(AL_EAXREVERB_ROOM_ROLLOFF_FACTOR, props->flRoomRolloffFactor);
			efxi(AL_EAXREVERB_DECAY_HFLIMIT, props->iDecayHFLimit);

		} else if ( token == "DENSITY" ) {
			efxf(AL_EAXREVERB_DENSITY, src.ParseFloat());
		} else if ( token == "DIFFUSION" ) {
			efxf(AL_EAXREVERB_DIFFUSION, src.ParseFloat());
		} else if ( token == "GAIN" ) {
			efxf(AL_EAXREVERB_GAIN, src.ParseFloat());
		} else if ( token == "GAINHF" ) {
			efxf(AL_EAXREVERB_GAINHF, src.ParseFloat());
		} else if ( token == "GAINLF" ) {
			efxf(AL_EAXREVERB_GAINLF, src.ParseFloat());
		} else if ( token == "DECAY_TIME" ) {
			efxf(AL_EAXREVERB_DECAY_TIME, src.ParseFloat());
		} else if ( token == "DECAY_HFRATIO" ) {
			efxf(AL_EAXREVERB_DECAY_HFRATIO, src.ParseFloat());
		} else if ( token == "DECAY_LFRATIO" ) {
			efxf(AL_EAXREVERB_DECAY_LFRATIO, src.ParseFloat());
		} else if ( token == "REFLECTIONS_GAIN" ) {
			efxf(AL_EAXREVERB_REFLECTIONS_GAIN, src.ParseFloat());
		} else if ( token == "REFLECTIONS_DELAY" ) {
			efxf(AL_EAXREVERB_REFLECTIONS_DELAY, src.ParseFloat());
		} else if ( token == "REFLECTIONS_PAN" ) {
			float x = src.ParseFloat(), y = src.ParseFloat(), z = src.ParseFloat();
			efxfv(AL_EAXREVERB_REFLECTIONS_PAN, x, y, z);
		} else if ( token == "LATE_REVERB_GAIN" ) {
			efxf(AL_EAXREVERB_LATE_REVERB_GAIN, src.ParseFloat());
		} else if ( token == "LATE_REVERB_DELAY" ) {
			efxf(AL_EAXREVERB_LATE_REVERB_DELAY, src.ParseFloat());
		} else if ( token == "LATE_REVERB_PAN" ) {
			float x = src.ParseFloat(), y = src.ParseFloat(), z = src.ParseFloat();
			efxfv(AL_EAXREVERB_LATE_REVERB_PAN, x, y, z);
		} else if ( token == "ECHO_TIME" ) {
			efxf(AL_EAXREVERB_ECHO_TIME, src.ParseFloat());
		} else if ( token == "ECHO_DEPTH" ) {
			efxf(AL_EAXREVERB_ECHO_DEPTH, src.ParseFloat());
		} else if ( token == "MODULATION_TIME" ) {
			efxf(AL_EAXREVERB_MODULATION_TIME, src.ParseFloat());
		} else if ( token == "MODULATION_DEPTH" ) {
			efxf(AL_EAXREVERB_MODULATION_DEPTH, src.ParseFloat());
		} else if ( token == "AIR_ABSORPTION_GAINHF" ) {
			efxf(AL_EAXREVERB_AIR_ABSORPTION_GAINHF, src.ParseFloat());
		} else if ( token == "HFREFERENCE" ) {
			efxf(AL_EAXREVERB_HFREFERENCE, src.ParseFloat());
		} else if ( token == "LFREFERENCE" ) {
			efxf(AL_EAXREVERB_LFREFERENCE, src.ParseFloat());
		} else if ( token == "ROOM_ROLLOFF_FACTOR" ) {
			efxf(AL_EAXREVERB_ROOM_ROLLOFF_FACTOR, src.ParseFloat());
		} else if ( token == "DECAY_HFLIMIT" || token == "DECAYHF_LIMIT" ) {
			efxi(AL_EAXREVERB_DECAY_HFLIMIT, src.ParseBool());
		} else {
			src.Error("idEFXFile::ReadEffect: Invalid parameter %s in reverb definition", token.c_str());
			src.ParseRestOfLine(token);
		}
	}

	return true;
}

/*
===============
idEFXFile::LoadFile
===============
*/
bool idEFXFile::LoadFile( const char *filename/*, bool OSPath*/ ) {
	idLexer src( LEXFL_NOSTRINGCONCAT | LEXFL_NOFATALERRORS );
	idToken token;

	efxFilename = filename;
	src.LoadFile( filename/*, OSPath*/ );
	if ( !src.IsLoaded() ) {
		return false;
	}

	if ( !src.ExpectTokenString( "Version" ) ) {
		return false;
	}

	version = src.ParseInt();
	if ( version != 1 && version != 2 ) {
		src.Error( "idEFXFile::LoadFile: Unknown file version %d", version );
		return false;
	}
	
	while (!src.EndOfFile()) {
		idSoundEffect *effect = new idSoundEffect;

		if (!effect->alloc()) {
			delete effect;
			Clear();
			return false;
		}

		bool ok = false;
		if (version == 1)
			ok = ReadEffectLegacy(src, effect);
		else
			ok = ReadEffectOpenAL(src, effect);

		if (!ok) {
			delete effect;
			break;
		}

		effects.Append(effect);
	};

	return true;
}

/*
===============
idEFXFile::Reload
===============
*/
bool idEFXFile::Reload() {
	if (efxFilename.IsEmpty()) {
		common->Warning("EFX file was not loaded, skipping reload");
		return false;
	}
	//drop all idSoundEffect-s, delete all related OpenAL objects
	Clear();
	//mark that we reloaded the EFX file, all effects must be updated
	isAfterReload = true;
	//read all effects from file again
	return LoadFile(efxFilename);
}

/*
===============
idEFXFile::IsAfterReload
===============
*/
bool idEFXFile::IsAfterReload() {
	bool res = isAfterReload;
	isAfterReload = false;
	return res;
}
