/*****************************************
 * This file is part of Impulse Framework.

    Impulse Framework is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    any later version.

    Impulse Framework is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with Impulse Framework.  If not, see <http://www.gnu.org/licenses/>.
*****************************************/

using UnityEngine;
using System.Collections;
[RequireComponent (typeof(AudioSource))]
public class MusicManager : MonoBehaviour {
	public static MusicManager Instance;	        // Singleton
	[SerializeField]
	private float volume;
	public float Volume {
		get {
			return source.volume;
		}
		set {
			volume = value;
			source.volume = value;
		}
	}

	public MusicPlaylist Playlist;
	public bool Shuffle;

	public RepeatMode Repeat;
	public float FadeDuration;
	public bool PlayOnAwake;

	private AudioSource source;


	void Start () {
		// If there is no instance of this class, set it.
		if (Instance == null) {
			DontDestroyOnLoad (gameObject); // Don't destroy this object
			Instance = this;
		} else {
			Debug.LogError ("There is already a Music Manager in the scene.");
			GameObject.Destroy (this);
		}

		// create a game object and add an AudioSource to it, to play music on
		source = gameObject.GetComponent<AudioSource>();
		source.name = "MusicAudioSource";
		source.playOnAwake = false;
		if (FadeDuration > 0)
			source.volume = 0f;
		else
			Volume = volume;
		if (Playlist == null)
			return;
		if (Playlist.MusicList.Length > 0)
			source.clip = Playlist.MusicList [0];
		else 
		{
			Debug.LogError ("There are no music in the list");
		}


		if (PlayOnAwake)
			Play ();
	}

	public void Play()
	{
		StartCoroutine (PlayMusicList ());
	}

	public void Stop(bool fade)
	{
		StopAllCoroutines ();
		if (fade)
			StartCoroutine(StopWithFade());
		else
			source.Stop();
	}

	public void Next()
	{
		source.Stop ();
	}

	public void ChangePlaylist(MusicPlaylist list)
	{
		Playlist = list;
		_counter = 0;
		StopAllCoroutines();
		StartCoroutine(ChangePlaylistE());
	}

	private IEnumerator ChangePlaylistE()
	{
		if (source.isPlaying)
			yield return StartCoroutine(StopWithFade());
		StartCoroutine(PlayMusicList());
	}

	private IEnumerator StopWithFade()
	{
		if (FadeDuration > 0)
		{
			float lerpValue = 0f;
			while (lerpValue < 1f) {
				lerpValue += Time.deltaTime / FadeDuration;
				source.volume = Mathf.Lerp (volume, 0f, lerpValue);
				yield return null;
			}
		}
		source.Stop();
	}

	public void PlaySong(AudioClip song)
	{
		StartCoroutine (PlaySongE (song));
	}

	private IEnumerator PlaySongE(AudioClip clip)
	{
		source.Stop ();
		source.clip = clip;
		StartCoroutine (FadeIn ());
		source.Play ();
		while (source.isPlaying) {
			if (source.clip.length - source.time <= FadeDuration) {
				yield return StartCoroutine (FadeOut ());
			}
			yield return null;
		}
	}

	private int _counter = 0;
	private IEnumerator PlayMusicList()
	{
		while (true)
		{
			yield return StartCoroutine (PlaySongE (Playlist.MusicList [_counter]));
			if (RepeatMode.Track == Repeat) 
			{
			}
			else if (Shuffle) {
				int newTrack = GetNewTrack ();
				while (newTrack == _counter) 
				{
					newTrack = GetNewTrack ();
				}
				_counter = newTrack;

			} 
			else 
			{
				_counter++;
				if (_counter >= Playlist.MusicList.Length-1) 
				{
					if (Repeat == RepeatMode.Playlist)
						_counter = 0;
					else
						yield break;
				}
			}
		}
	}

	private IEnumerator FadeOut()
	{
		if (FadeDuration > 0f) {
			float startTime = source.clip.length - FadeDuration;
			float lerpValue = 0f;
			while (lerpValue < 1f) {
				lerpValue = Mathf.InverseLerp (startTime, source.clip.length, source.time);
				source.volume = Mathf.Lerp (volume, 0f, lerpValue);
				yield return null;
			}
		} else {
			yield break;
		}
	}

	private IEnumerator FadeIn()
	{
		if (FadeDuration > 0f)
		{
			float lerpValue = 0f;
			while (lerpValue < 1f) {
				lerpValue = Mathf.InverseLerp (0f, FadeDuration, source.time);
				source.volume = Mathf.Lerp (0f, volume, lerpValue);
				yield return null;
			}
		}
		else
		{
			yield break;
		}
	}

	private int GetNewTrack()
	{
		return Random.Range (0, Playlist.MusicList.Length);
	}
}
public enum RepeatMode
{
	Playlist,
	Track,
	None
}