using System.Collections;
using AibisDream.Kit;
using UnityEngine;
using Yarn.Unity;

namespace AibisDream
{
    public class AudioManager : Singleton<AudioManager>
    {
        private const string LoopSource = "Loop";
        private const string InteractionSource = "Interaction";
        private const string VoiceSource = "Voice";
        private const string MemorySource = "Memery";
        private const string Amb1Source = "Amb1";
        private const string Amb2Source = "Amb2";

        private AudioSource _loopSource;
        private AudioSource _interactionSource;
        private AudioSource _voiceSource;
        private AudioSource _memorySource;
        private AudioSource _amb1Source;
        private AudioSource _amb2Source;

        public float fadeTime;

        public override void OnSingletonInit()
        {
            _loopSource = transform.Find(LoopSource).GetComponent<AudioSource>();
            _interactionSource = transform.Find(InteractionSource).GetComponent<AudioSource>();
            _voiceSource = transform.Find(VoiceSource).GetComponent<AudioSource>();
            _memorySource = transform.Find(MemorySource).GetComponent<AudioSource>();
            _amb1Source = transform.Find(Amb1Source).GetComponent<AudioSource>();
            _amb2Source = transform.Find(Amb2Source).GetComponent<AudioSource>();
        }

        #region 随机播放

        public void RandomPlayVoice(string voicePath)
        {
            AudioClip clip = RandomLoadAudioClip(3, $"Audio/{voicePath}");
            _voiceSource.clip = clip;
            _voiceSource.Play();
        }

        [YarnCommand("random_play_interaction")]
        public static void RandomPlayInteraction(string interactionName)
        {
            AudioClip clip = Instance.RandomLoadAudioClip(3, $"Audio/{interactionName}");
            if (clip == null)
            {
                clip = Resources.Load<AudioClip>($"Audio/{interactionName}");
            }

            Instance._voiceSource.clip = clip;
            Instance._voiceSource.Play();
        }

        public void StopVoice()
        {
            if (_voiceSource.isPlaying)
            {
                _voiceSource.Stop();
            }
        }

        [YarnCommand("stop_interaction")]
        public static void StopInteraction()
        {
            Instance._interactionSource.Stop();
        }

        #endregion

        #region 播放唱歌

        public void PlayVoice(string actorName, string voiceName)
        {
            AudioClip clip = RandomLoadAudioClip(3, $"Audio/{actorName}");
            _voiceSource.clip = clip;
            _voiceSource.Play();
        }

        #endregion

        #region 循环播放

        [YarnCommand("play_loop_audio")]
        public static void PlayLoopAudio(string audioName)
        {
            AudioClip clip = Resources.Load<AudioClip>($"Audio/{audioName}");
            if (clip == null)
            {
                clip = Instance.RandomLoadAudioClip(3, $"Audio/{audioName}");
            }

            Instance._loopSource.clip = clip;
            Instance._loopSource.Play();
        }

        [YarnCommand("pause_loop_audio")]
        public static void PauseLoopAudio()
        {
            Instance._loopSource.Pause();
        }

        public void ContinueLoopAudio()
        {
            _loopSource.UnPause();
        }

        public bool IsLoopPlaying()
        {
            return _loopSource.isPlaying;
        }

        #endregion

        #region 背景音循环播放

        [YarnCommand("play_amb1_audio")]
        public static void PlayAmb1Audio(string audioName)
        {
            Instance._amb1Source.Stop();
            AudioClip clip = Resources.Load<AudioClip>($"Audio/{audioName}");
            Instance._amb1Source.clip = clip;
            Instance._amb1Source.volume = 0f;
            Instance._amb1Source.Play();
            Instance.StartCoroutine(Instance.FadeTo(1.0f, Instance.fadeTime, Instance._amb1Source));
        }

        [YarnCommand("pause_amb1_audio")]
        public static void PauseAmb1Audio()
        {
            Instance._amb1Source.Pause();
        }

        [YarnCommand("fade_out_amb1_audio")]
        public static void FadeOutAmb1Audio()
        {
            Instance.StartCoroutine(Instance.FadeTo(0.0f, Instance.fadeTime, Instance._amb1Source));
        }

        public void ContinueAmb1Audio()
        {
            _amb1Source.volume = 0.0f;
            _amb1Source.UnPause();
            StartCoroutine(FadeTo(1.0f, fadeTime, _amb1Source));
        }

        [YarnCommand("play_amb2_audio")]
        public static void PlayAmb2Audio(string audioName)
        {
            Instance._amb2Source.Stop();
            AudioClip clip = Resources.Load<AudioClip>($"Audio/{audioName}");
            Instance._amb2Source.clip = clip;
            Instance._amb2Source.volume = 0f;
            Instance._amb2Source.Play();
            Instance.StartCoroutine(Instance.FadeTo(1.0f, Instance.fadeTime, Instance._amb2Source));
        }

        [YarnCommand("pause_amb2_audio")]
        public static void PauseAmb2Audio()
        {
            Instance._amb2Source.Pause();
        }

        [YarnCommand("fade_out_amb2_audio")]
        public static void FadeOutAmb2Audio()
        {
            Instance.StartCoroutine(Instance.FadeTo(0.0f, Instance.fadeTime, Instance._amb2Source));
        }

        public void ContinueAmb2Audio()
        {
            _amb2Source.volume = 0.0f;
            _amb2Source.UnPause();
            StartCoroutine(FadeTo(1.0f, fadeTime, _amb2Source));
        }

        #endregion

        #region 播放记忆

        public void PlayMemoryAudio(string memoryName)
        {
            StartCoroutine(AsyncPlayMemoryAudio(memoryName));
        }

        public void PauseMemoryAudio()
        {
            _memorySource.Pause();
        }

        public void ContinueMemoryAudio()
        {
            _memorySource.volume = 0.0f;
            _memorySource.Play();
            StartCoroutine(FadeTo(1.0f, fadeTime, _memorySource));
        }

        #endregion

        public void FadeInLoopAudio(string audioName)
        {
            AudioClip clip = Resources.Load<AudioClip>(audioName);
            _loopSource.clip = clip;
            _loopSource.volume = 0.0f;
            _loopSource.Play();
            StartCoroutine(FadeTo(1.0f, 5f, _loopSource));
        }

        private IEnumerator FadeTo(float targetVolume, float duration, AudioSource audioSource)
        {
            float startVolume = audioSource.volume;
            float timeElapsed = 0f;

            while (timeElapsed < duration)
            {
                timeElapsed += Time.deltaTime;
                audioSource.volume = Mathf.Lerp(startVolume, targetVolume, timeElapsed / duration);
                yield return null;
            }

            audioSource.volume = targetVolume;
        }

        private AudioClip RandomLoadAudioClip(int audioSize, string path)
        {
            int randomIndex = Random.Range(0, audioSize) + 1;
            return Resources.Load<AudioClip>($"{path}_{randomIndex}");
        }

        private IEnumerator AsyncPlayMemoryAudio(string memoryName)
        {
            AudioClip intro = Resources.Load<AudioClip>($"Audio/mem_play");
            AudioClip loop = Resources.Load<AudioClip>($"Audio/{memoryName}");
            _memorySource.clip = intro;
            _memorySource.loop = false;
            _memorySource.Play();
            yield return new WaitForSeconds(intro.length);
            _memorySource.clip = loop;
            _memorySource.loop = true;
            _memorySource.Play();
        }
    }
}