using System.Collections;
using System.Collections.Generic;
using UnityEngine;

using System;

public class SoundPlayer : MonoBehaviour
{
    public static readonly int defaultClickPositiveAudio = 1;
    public static readonly int defaultClickNegativeAudio = 2;

    static readonly List<int> commonUseAudioSet = new List<int>() { defaultClickPositiveAudio, defaultClickNegativeAudio, 3, 4 };

    public static SoundPlayer Instance {
        get; set;
    }

    [SerializeField] AudioSource m_MusicAudioSource;
    public AudioSource musicAudioSource { get { return m_MusicAudioSource; } }

    [SerializeField] AudioSource m_UIAudioSource;
    [SerializeField] AudioSource m_NewBieAudioSource;
    [SerializeField] AudioSource m_NpcAudioSource;

    Dictionary<int, AudioClip> commonUseAudioClipDict = new Dictionary<int, AudioClip>();
    Dictionary<int, AudioClip> musicAudioClipDict = new Dictionary<int, AudioClip>();

    public event Action<bool> muteEvent;
    bool m_Mute = false;
    public bool mute {
        get { return m_Mute; }
        set {
            m_Mute = value;
            m_MusicAudioSource.mute = m_Mute;
            m_NewBieAudioSource.mute = m_Mute;
            m_NpcAudioSource.mute = m_Mute;

            if (muteEvent != null)
            {
                muteEvent(m_Mute);
            }
        }
    }

    public static void CreateSoundPlayer()
    {
        var gameObject = GameObject.Instantiate(BuiltInLoader.LoadPrefab("SoundPlayer"));
        Instance = gameObject.GetComponent<SoundPlayer>();
        Instance.name = "SoundPlayer";
        Instance.SetActive(true);
        DontDestroyOnLoad(gameObject);
    }

    public void PlayBackGroundMusic(int _audioId)
    {
        if (_audioId <= 0)
        {
            return;
        }

        backGroudAudioIdRef = _audioId;
        AudioClip clip = null;
        if (!commonUseAudioClipDict.TryGetValue(_audioId, out clip))
        {
            var config = AudioConfig.Get(_audioId);
            if (config != null)
            {
                AudioLoader.LoadAudioAsync(config.Folder, config.Audio, (bool _ok, UnityEngine.Object _object) =>
                {
                    if (_ok && _object != null)
                    {
                        clip = _object as AudioClip;
                        if (clip != null)
                        {
                            if (!musicAudioClipDict.ContainsKey(_audioId))
                            {
                                musicAudioClipDict[_audioId] = clip;
                            }

                            StartCoroutine(Co_BackGroundMusicFadeOutIn(clip, false));
                        }
                    }
                });
            }
        }
        else
        {
            if (clip != null)
            {
                StartCoroutine(Co_BackGroundMusicFadeOutIn(clip, false));
            }
        }
    }

    int backGroudAudioIdRef = 0;
    public void PlayBackGroundMusicOneShot(int _audioId)
    {
        var config = AudioConfig.Get(_audioId);
        if (config == null)
        {
            return;
        }

        var clip = AudioLoader.LoadAudio(config.Folder, config.Audio);
        if (clip == null)
        {
            return;
        }

        var second = clip.length;
        StartCoroutine(Co_BackGroundMusicFadeOutIn(clip, true));

        if (backGroudAudioIdRef != 0)
        {
            StartCoroutine(Co_DelayPlayBackGrondMusic(second, backGroudAudioIdRef));
        }
    }

    public void StopBackGroundMusic()
    {
        backGroudAudioIdRef = 0;
        StartCoroutine(Co_BackGroundMusicFadeOut());
    }

    public void UnLoadMusic(int _exclude)
    {
        if (AssetSource.isUseAssetBundle && DeviceUtility.IsLowMemory())
        {
            foreach (var key in musicAudioClipDict.Keys)
            {
                if (key != _exclude)
                {
                    var config = AudioConfig.Get(key);
                    ResManager.Instance.UnloadAsset("Audio/" + config.Folder, config.Audio);
                }
            }

            var keys = new List<int>(musicAudioClipDict.Keys);
            for (int i = 0; i < keys.Count; i++)
            {
                if (keys[i] != _exclude)
                {
                    musicAudioClipDict.Remove(keys[i]);
                }
            }
        }
    }

    public void PlayUIAudio(int _audioId)
    {
        if (_audioId <= 0)
        {
            return;
        }

        AudioClip clip = null;
        if (!commonUseAudioClipDict.TryGetValue(_audioId, out clip))
        {
            var config = AudioConfig.Get(_audioId);
            if (config != null)
            {
                clip = AudioLoader.LoadAudio(config.Folder, config.Audio);
                if (clip != null)
                {
                    if (commonUseAudioSet.Contains(_audioId))
                    {
                        commonUseAudioClipDict[_audioId] = clip;
                    }
                }
            }
        }

        if (clip != null)
        {
            m_UIAudioSource.volume = SystemSetting.Instance.GetSoundEffect();
            if (m_UIAudioSource.isPlaying)
            {
                m_UIAudioSource.Stop();
            }
            m_UIAudioSource.PlayOneShot(clip);
        }
    }

    public void StopUIAudio()
    {
        if (m_UIAudioSource.isPlaying)
        {
            m_UIAudioSource.Stop();
        }
    }

    public void PlayAudio(AudioSource _source, int _audioId)
    {
        if (_audioId <= 0)
        {
            return;
        }
        
        if (!_source)
        {
            return;
        }
        
        AudioClip clip = null;
        if (!commonUseAudioClipDict.TryGetValue(_audioId, out clip))
        {
            var config = AudioConfig.Get(_audioId);
            if (config != null)
            {
                clip = AudioLoader.LoadAudio(config.Folder, config.Audio);
                if (clip != null)
                {
                    if (commonUseAudioSet.Contains(_audioId))
                    {
                        commonUseAudioClipDict[_audioId] = clip;
                    }
                }
            }
        }

        if (clip != null)
        {
            _source.volume = SystemSetting.Instance.GetSoundEffect() * 1f;
            //  TODO YYL
                // (WindowCenter.Instance.ExistAnyFullScreenOrMaskWin() ? GeneralDefine.audioScaleWhenFullScreenOn : 1f);

            _source.PlayOneShot(clip);
        }
    }

    public void PlayAudio(AudioClip _clip)
    {
        if (_clip != null)
        {
            m_UIAudioSource.volume = SystemSetting.Instance.GetSoundEffect();
            if (m_UIAudioSource.isPlaying)
            {
                m_UIAudioSource.Stop();
            }
            m_UIAudioSource.PlayOneShot(_clip);
        }
    }

    public void PlayNewBieAudio(int _audioId)
    {
        if (_audioId <= 0)
        {
            return;
        }

        AudioClip clip = null;
        var config = AudioConfig.Get(_audioId);
        if (config != null)
        {
            clip = AudioLoader.LoadAudio(config.Folder, config.Audio);
        }

        if (clip != null)
        {
            m_NewBieAudioSource.volume = SystemSetting.Instance.GetSoundEffect();
            if (m_NewBieAudioSource.isPlaying)
            {
                m_NewBieAudioSource.Stop();
            }

            if (m_NpcAudioSource.isPlaying)
            {
                m_NpcAudioSource.Stop();
            }
            m_NewBieAudioSource.PlayOneShot(clip);
        }
    }

    public void PlayNpcAudio(int _audioId)
    {
        if (_audioId <= 0)
        {
            return;
        }

        AudioClip clip = null;
        var config = AudioConfig.Get(_audioId);
        if (config != null)
        {
            clip = AudioLoader.LoadAudio(config.Folder, config.Audio);
        }

        if (clip != null)
        {
            m_NpcAudioSource.volume = SystemSetting.Instance.GetSoundEffect();
            if (m_NpcAudioSource.isPlaying)
            {
                m_NpcAudioSource.Stop();
            }

            if (m_NewBieAudioSource.isPlaying)
            {
                m_NewBieAudioSource.Stop();
            }

            m_NpcAudioSource.PlayOneShot(clip);
        }
    }

    //public void PlayLoginMusic()
    //{
    //    var loginMusic = BuiltInLoader.LoadMusic("Music_Login");
    //    if (!m_MusicAudioSource.isPlaying || m_MusicAudioSource.clip != loginMusic)
    //    {
    //        StartCoroutine(Co_BackGroundMusicFadeOutIn(loginMusic, false));
    //    }
    //}

    //private void LateUpdate()
    //{
    //    if (CameraController.Instance != null && CameraController.Instance.CameraObject != null)
    //    {
    //        this.transform.position = CameraController.Instance.transform.position + new Vector3(0, 5, 0);
    //        this.transform.rotation = CameraController.Instance.CameraObject.transform.rotation;
    //    }
    //}

    IEnumerator Co_BackGroundMusicFadeOutIn(AudioClip _clip, bool _oneShot)
    {
        var timer = 0f;
        var startVolume = 0f;
        var toVolume = 0f;

        if (m_MusicAudioSource.isPlaying)
        {
            timer = 0f;
            startVolume = SystemSetting.Instance.GetSoundVolume();
            toVolume = 0f;

            while (timer < 0.5f)
            {
                timer += Time.deltaTime;
                m_MusicAudioSource.volume = Mathf.Lerp(startVolume, toVolume, Mathf.Clamp01(timer / 0.5f));
                yield return null;
            }

            m_MusicAudioSource.Stop();
        }

        if (_oneShot)
        {
            m_MusicAudioSource.PlayOneShot(_clip);
        }
        else
        {
            m_MusicAudioSource.clip = _clip;
            m_MusicAudioSource.Play();
        }

        timer = 0f;
        startVolume = 0f;
        toVolume = SystemSetting.Instance.GetSoundVolume();
        while (timer < 0.5f)
        {
            timer += Time.deltaTime;
            m_MusicAudioSource.volume = Mathf.Lerp(startVolume, toVolume, Mathf.Clamp01(timer / 0.5f));
            yield return null;
        }
    }

    IEnumerator Co_BackGroundMusicFadeOut()
    {
        if (m_MusicAudioSource.isPlaying)
        {
            var timer = 0f;
            var startVolume = SystemSetting.Instance.GetSoundVolume();
            var toVolume = 0f;

            while (timer < 1f)
            {
                timer += Time.deltaTime;
                m_MusicAudioSource.volume = Mathf.Lerp(startVolume, toVolume, timer);
                yield return null;
            }

            m_MusicAudioSource.Stop();
        }
    }

    IEnumerator Co_DelayPlayBackGrondMusic(float _delay, int _audioId)
    {
        yield return new WaitForSeconds(_delay);
        PlayBackGroundMusic(_audioId);
    }
}