package funkin.audio;

import flixel.group.FlxGroup.FlxTypedGroup;
import flixel.system.FlxSound;

/**
 * A group of FlxSounds which can be controlled as a whole.
 * 
 * Add sounds to the group using `add()`, and then control them
 * as a whole using the properties and methods of this class.
 * 
 * It is assumed that all the sounds will play at the same time,
 * and have the same duration.
 */
class FlxAudioGroup extends FlxTypedGroup<FlxSound>
{
	/**
	 * The position in time of the sounds in the group.
	 * Measured in milliseconds.
	 */
	public var time(get, set):Float;

	function get_time():Float
	{
		if (getFirstAlive() != null)
			return getFirstAlive().time;
		else
			return 0;
	}

	function set_time(time:Float):Float
	{
		forEachAlive(function(sound:FlxSound)
		{
			// account for different offsets per sound?
			sound.time = time;
		});

		return time;
	}

	/**
	 * The volume of the sounds in the group.
	 */
	public var volume(get, set):Float;

	function get_volume():Float
	{
		if (getFirstAlive() != null)
			return getFirstAlive().volume;
		else
			return 1.0;
	}

	function set_volume(volume:Float):Float
	{
		forEachAlive(function(sound:FlxSound)
		{
			sound.volume = volume;
		});

		return volume;
	}

	/**
	 * The pitch of the sounds in the group, as a multiplier of 1.0x.
	 * `2.0` would play the audio twice as fast with a higher pitch,
	 * and `0.5` would play the audio at half speed with a lower pitch.
	 */
	public var pitch(get, set):Float;

	function get_pitch():Float
	{
		#if FLX_PITCH
		if (getFirstAlive() != null)
			return getFirstAlive().pitch;
		else
		#end
		return 1;
	}

	function set_pitch(val:Float):Float
	{
		#if FLX_PITCH
		trace('Setting audio pitch to ' + val);
		forEachAlive(function(sound:FlxSound)
		{
			sound.pitch = val;
		});
		#end
		return val;
	}

	/**
	 * Whether members of the group should be destroyed when they finish playing.
	 */
	public var autoDestroyMembers(default, set):Bool = false;

	function set_autoDestroyMembers(value:Bool):Bool
	{
		autoDestroyMembers = value;
		forEachAlive(function(sound:FlxSound)
		{
			sound.autoDestroy = value;
		});
		return value;
	}

	/**
	 * Add a sound to the group.
	 */
	public override function add(sound:FlxSound):FlxSound
	{
		var result:FlxSound = super.add(sound);

		if (result == null)
			return;

		// Apply parameters to the new sound.
		result.autoDestroy = this.autoDestroyMembers;
		result.pitch = this.pitch;
		result.volume = this.volume;

		// We have to play, then pause the sound to set the time,
		// else the sound will restart immediately when played.
		result.play(true, 0.0);
		result.pause();
		result.time = this.time;
	}

	/**
	 * Pause all the sounds in the group.
	 */
	public function pause()
	{
		forEachAlive(function(sound:FlxSound)
		{
			sound.pause();
		});
	}

	/**
	 * Play all the sounds in the group.
	 */
	public function play(forceRestart:Bool = false, startTime:Float = 0.0, ?endTime:Float)
	{
		forEachAlive(function(sound:FlxSound)
		{
			sound.play(forceRestart, startTime, endTime);
		});
	}

	/**
	 * Resume all the sounds in the group.
	 */
	public function resume()
	{
		forEachAlive(function(sound:FlxSound)
		{
			sound.resume();
		});
	}

	/**
	 * Stop all the sounds in the group.
	 */
	public function stop()
	{
		forEachAlive(function(sound:FlxSound)
		{
			sound.stop();
		});
	}

    public override function clear():Void {
        this.stop();

        super.clear();
    }

	/**
	 * Calculates the deviation of the sounds in the group from the target time.
	 * 
	 * @param targetTime The time to compare the sounds to.
	 *             If null, the current time of the first sound in the group is used.
	 * @return The largest deviation of the sounds in the group from the target time.
	 */
	public function calcDeviation(?targetTime:Float):Float
	{
		var deviation:Float = 0;

		forEachAlive(function(sound:FlxSound)
		{
			if (targetTime == null)
				targetTime = sound.time;
			else
			{
				var diff:Float = sound.time - targetTime;
				if (Math.abs(diff) > Math.abs(deviation))
					deviation = diff;
			}
		});

		return deviation;
	}
}