/**
    * Copyright (c) 2011, The University of Southampton and the individual contributors.
    * All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without modification,
    * are permitted provided that the following conditions are met:
    *
    *   * 	Redistributions of source code must retain the above copyright notice,
    * 	this list of conditions and the following disclaimer.
   *
   *   *	Redistributions in binary form must reproduce the above copyright notice,
   * 	this list of conditions and the following disclaimer in the documentation
   * 	and/or other materials provided with the distribution.
   *
   *   *	Neither the name of the University of Southampton nor the names of its
   * 	contributors may be used to endorse or promote products derived from this
   * 	software without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
   * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
   * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  /**
   *
   */
  package org.openimaj.audio;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.openimaj.audio.processor.AudioProcessor;
  import org.openimaj.audio.processor.FixedSizeSampleAudioProcessor;
  import org.openimaj.audio.samples.SampleBuffer;
  import org.openimaj.audio.samples.SampleBufferFactory;
  import org.openimaj.audio.timecode.AudioTimecode;
  
  /**
   * A basic audio mixer that takes a number of {@link AudioStream}s and mixes
   * then with some gain compensation into a single audio stream.
   * 
   * @author David Dupplaw (dpd@ecs.soton.ac.uk)
   * @created 23rd November 2011
   */
  public class AudioMixer extends AudioStream
  {
  	/**
  	 * A listener for objects that wish to be informed of a mix event. The mix
  	 * event provides the sample buffers of all the channels and the sample
  	 * buffer of the mixed stream. It is called before the mixed stream chunk is
  	 * returned from each mix event.
  	 * 
  	 * @author David Dupplaw (dpd@ecs.soton.ac.uk)
  	 * 
  	 * @created 29 Nov 2011
  	 */
  	public interface MixEventListener
  	{
  		/**
  		 * Callback for a mix event.
  		 * 
  		 * @param channels
  		 *            the channels being mixed
  		 * @param mix
  		 *            the mixed channel
  		 */
  		public void mix(SampleBuffer[] channels, SampleBuffer mix);
  	}
  
  	/** A list of the audio streams to mix in this mixer */
  	private final List<AudioStream> streams = new ArrayList<AudioStream>();
  	private final List<Float> gain = new ArrayList<Float>();
  	private final Map<AudioStream, AudioStream> streamMap = new HashMap<AudioStream, AudioStream>();
  
  	/** The currently processed sample in the mixer */
  	private SampleBuffer currentSample = null;
  
  	/** The size of each mix - the sample buffer size */
  	private int bufferSize = 256;
  
  	/**
  	 * If set to TRUE, this will cause the mixer to run even when there are not
  	 * streams to play. It does this by returning empty sample chunks.
  	 */
  	private boolean alwaysRun = true;
  
  	/** The time the mixer started */
  	private long startMillis = -1;
  
  	/** The timecode we're using */
  	private AudioTimecode timecode = null;
 
 	/** Listeners of the mix event */
 	private final List<MixEventListener> mixEventListeners =
 			new ArrayList<MixEventListener>();
 
 	/** Whether or not to fire mix events */
 	private boolean fireMixEvents = false;
 
 	/**
 	 * Default constructor that takes the format for the samples. All streams
 	 * added to this mixer must conform to that sample format.
 	 * 
 	 * @param af
 	 *            The {@link AudioFormat}
 	 */
 	public AudioMixer(final AudioFormat af)
 	{
 		this.setFormat(af);
 
 		// Create the current sample chunk that we'll reuse
 		this.currentSample = SampleBufferFactory.createSampleBuffer(af, this.bufferSize);
 
 		this.timecode = new AudioTimecode(0);
 	}
 
 	/**
 	 * The timecode object
 	 * 
 	 * @param tc
 	 *            The timecode object.
 	 */
 	public void setTimecodeObject(final AudioTimecode tc)
 	{
 		this.timecode = tc;
 	}
 
 	/**
 	 * Add an {@link AudioStream} to this mixer. It must conform to the same
 	 * format as this mixer. If not, an {@link IllegalArgumentException} will be
 	 * thrown.
 	 * 
 	 * @param as The {@link AudioStream} to add to this mixer.
 	 * @param defaultGain
 	 *            The default gain of this stream.
 	 */
 	public void addStream(final AudioStream as, final float defaultGain)
 	{
 		if (as.format.equals(this.getFormat()))
 		{
 			AudioStream stream = as;
 
 			// It's important that the incoming sample chunks from
 			// the input streams are equal in length, so we wrap them
 			// all in FixedSampleSizeAudioProcessor. However, before we
 			// do we check whether they already are fixed sized chunks.
 			// We can't check with just a instanceof because that will also
 			// be true for subclasses and we can't be sure they're doing more.
 			// So, we must check ONLY for instances of EXACTLY
 			// FixedSampleSizeAudioProcessors.
 			if (stream.getClass().getName().equals(
 					FixedSizeSampleAudioProcessor.class.getName()))
 			{
 				// Get the underlying stream.
 				stream = ((AudioProcessor) as).getUnderlyingStream();
 			}
 
 			// Set the gain
 			this.gain.add(defaultGain);
 
 			// Add the stream wrapped in a fixed size audio processor.
 			synchronized (this.streams)
 			{
 				// Wrap the stream in a FixedSizeSampleAudioProcessor
 				final FixedSizeSampleAudioProcessor fssap =
 						new FixedSizeSampleAudioProcessor(stream, this.bufferSize);
 				this.streams.add(fssap);
 				this.streamMap.put(as, fssap);
 			}
 		}
 		else
 			throw new IllegalArgumentException("Format of added stream is " +
 					"incompatible with the mixer.");
 	}
 
 	/**
 	 * {@inheritDoc}
 	 * 
 	 * @see org.openimaj.audio.AudioStream#nextSampleChunk()
 	 */
 	@Override
 	synchronized public SampleChunk nextSampleChunk()
 	{
 		// If there are no streams attached to this mixer, then
 		// we return null - end of mixer stream.
 		if (this.streams.size() == 0 && !this.alwaysRun)
 			return null;
 
 		// Set the time the mixer started
 		if (this.startMillis == -1)
 			this.startMillis = System.currentTimeMillis();
 
 		// Get the next sample chunk from each stream.
 		final SampleBuffer sb = this.currentSample;
 		SampleChunk sc = null;
 
 		final List<SampleBuffer> chunkList = new ArrayList<SampleBuffer>();
 		synchronized (this.streams)
 		{
 			for (int stream = 0; stream < this.streams.size(); stream++)
 			{
 				// We can do this because the sample chunks from all the streams
 				// are forced to be the same size!
 				sc = this.streams.get(stream).nextSampleChunk();
 
 				// Get the next chunk and add it to a list for going through
 				// later
 				if (sc != null)
 				{
 					// System.out.println(
 					// this+" Stream "+stream+" size "+sc.getNumberOfSamples()
 					// );
 					chunkList.add(sc.getSampleBuffer());
 				}
 				else
 				{
 					// Got to the end of the stream, so we'll remove it
 					this.streams.remove(stream);
 					this.gain.remove(stream);
 				}
 			}
 
 			// System.out.println( chunkList +" -> "+this.gain );
 
 			// Now create the new sample chunk by averaging the samples
 			// at each point from all streams
 			for (int i = 0; i < sb.size(); i++)
 			{
 				float Z = 0;
 				for (int stream = 0; stream < chunkList.size(); stream++)
 					if (chunkList.get(stream) != null)
 						Z += chunkList.get(stream).get(i) * this.gain.get(stream);
 
 				// Set the value in the new sample buffer
 				sb.set(i, Z);
 			}
 		}
 
 		// Fire the mix event
 		if (this.fireMixEvents)
 			for (final MixEventListener mel : this.mixEventListeners)
 				mel.mix(chunkList.toArray(new SampleBuffer[0]), sb);
 
 		// Create a SampleChunk for our mix stream
 		sc = sb.getSampleChunk();
 
 		this.timecode.setTimecodeInMilliseconds(System.currentTimeMillis() -
 				this.startMillis);
 		sc.setStartTimecode(this.timecode);
 
 		return sc;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 * 
 	 * @see org.openimaj.audio.AudioStream#reset()
 	 */
 	@Override
 	public void reset()
 	{
 		// No implementation
 	}
 
 	/**
 	 * Set the size of the buffer that the mixer will mix. Note that this must
 	 * be done before any streams are added to the mixer.
 	 * 
 	 * @param bufferSize
 	 *            The buffer size in samples per channel.
 	 */
 	public void setBufferSize(final int bufferSize)
 	{
 		this.bufferSize = bufferSize;
 		this.currentSample = SampleBufferFactory.createSampleBuffer(
 				this.format, bufferSize);
 	}
 
 	/**
 	 * Whether to run the mixer when there are no audio streams to mix.
 	 * 
 	 * @param alwaysRun
 	 *            TRUE to make the mixer always run.
 	 */
 	public void setAlwaysRun(final boolean alwaysRun)
 	{
 		this.alwaysRun = alwaysRun;
 	}
 
 	/**
 	 * Add a mix event listener to this AudioMixer.
 	 * 
 	 * @param mel
 	 *            The {@link MixEventListener} to add
 	 */
 	public void addMixEventListener(final MixEventListener mel)
 	{
 		this.mixEventListeners.add(mel);
 	}
 
 	/**
 	 * Remove the given {@link MixEventListener} from this mixer.
 	 * 
 	 * @param mel
 	 *            The {@link MixEventListener} to remove
 	 */
 	public void removeMixEventListener(final MixEventListener mel)
 	{
 		this.mixEventListeners.remove(mel);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 * 
 	 * @see org.openimaj.audio.AudioStream#getLength()
 	 */
 	@Override
 	public long getLength()
 	{
 		return -1;
 	}
 
 	/**
 	 * Whether to fire mix events or not (default is that the mixer doesn't)
 	 * 
 	 * @param tf
 	 *            TRUE to fire mix events.
 	 */
 	public void setMixEvents(final boolean tf)
 	{
 		this.fireMixEvents = tf;
 	}
 
 	/**
 	 * Remove the given audio stream from the mixer.
 	 * 
 	 * @param as The audio stream to remove
 	 */
 	public void removeStream(final AudioStream as)
 	{
 		synchronized (this.streams)
 		{
 			AudioStream aas = this.streamMap.get(as);
 			if (aas == null)
 				aas = as;
 
 			System.out.println("Removing " + aas + " from " + this.streams);
 			this.gain.remove(this.streams.indexOf(aas));
 			this.streams.remove(this.streams.indexOf(aas));
 		}
 	}
 }