using PhxhSDK;
using System;
using Framework;
using System.Collections.Generic;
using cfg.AudioCfg;
using CriWare;
using CriWare.Assets;
using Cysharp.Threading.Tasks;
using UnityEngine;
using UnityEngine.SceneManagement;
using Object = UnityEngine.Object;
using Constants = Framework.Constants;

    public class AudioCriwareManager : Singlenton<AudioCriwareManager>, IStart, IInitable, IUpdatable, IAudioPlay
{
    public GameObject initGameObject;

    public ClipType curClipType;

    protected float vol = 1f;
    protected float musicVol = 1f;
    protected float soundsVol = 1f;
    protected float speakVol = 1f;

    protected Dictionary<int, Audio> musicAudio;
    protected Dictionary<int, Audio> soundsAudio;
    protected Dictionary<string, int> loadingAcb;
    private List<GameObject> _rootGoList;
    private Dictionary<GameObject, Audio> _audioDic;
    /// <summary>
    /// 背景音乐播放器
    /// </summary>
    private Audio _bgmAudio;
    public Audio BgmAudio
    {
        get { return _bgmAudio; }
    }

    protected static int SOUNDS_POOL_MAX_NUM = 25;
    protected static int MUSIC_POOL_MAX_NUM = 5;

    protected bool banMusic = false;
    protected bool banSound = false;

    protected bool initialized = false;

    protected List<int> _toBeRemoved = new List<int>();

    private bool _isOpenSpeakVoice = true;

    private GameObject _criError;
    private GameObject _criAtomGo;

    private static Queue<Audio> _freeMusicAudio;
    private static Queue<Audio> _freeSoundsAudio;
    private Audio _oldestSound;

    private Dictionary<string, bool> _isAcbLoadedDic = new Dictionary<string, bool>();
    private Dictionary<string, CriAtomAcbAsset> _LoadedAcbAssetDic = new Dictionary<string, CriAtomAcbAsset>();

    private CriAtomListener _listener;

    public CriAtomExOutputAnalyzer analyzer=null;
    public bool IsAnalyzer = false;

    private string _musicAssetPath = "Assets/Audio/Music/NLD_BGM";
    private string _soundAssetPath = "Assets/Audio/Music/CueSheet_ProjNLD";
    private string _speakAssetPath = "Assets/Audio/Music/CueSheet_VOICE";
    private string _assetPath0 = "Assets/Audio/Music/CueSheet_SE";
    public void Start()
    {
        if (initGameObject == null)
        {
            // Need to create a new GameObject to attach the singleton to.
            curClipType = ClipType.CriwareClip;

            initGameObject = new GameObject();
            initGameObject.name = "AudioOld(Singleton)";
            //initGameObject.hideFlags = HideFlags.HideInHierarchy;
            // Make instance persistent.
            Object.DontDestroyOnLoad(initGameObject);
            //Object.DontDestroyOnLoad(GameObject.Find("CriWareLibraryInitializer"));
//#if UNITY_EDITOR
            // if (curClipType == ClipType.CriwareClip)
            // {
            //     _criError = new GameObject();
            //     _criError.name = "CriwareError";
            //     _criError.AddComponent<CriWareErrorHandler>();
            //     Object.DontDestroyOnLoad(_criError);
            // }

            _rootGoList = new List<GameObject>();
            _audioDic = new Dictionary<GameObject, Audio>();
            for (int i = 0; i < MUSIC_POOL_MAX_NUM + SOUNDS_POOL_MAX_NUM; i++)
            {
                var go = new GameObject();
                go.name = "Audio";
                go.transform.SetParent(initGameObject.transform);
                _rootGoList.Add(go);
            }
            
            _PreLoadAssets();
//#endif
        }
    }

    private async void _PreLoadAssets()
    {
        if (AudioManager.DisableAudio) return;
        await LoadAudioAsync(AudioType.MUSIC, _musicAssetPath);
        await LoadAudioAsync(AudioType.SOUND, _soundAssetPath);
        await LoadAudioAsync(AudioType.SOUND, _speakAssetPath);
        await LoadAudioAsync(AudioType.SOUND, _assetPath0);
    }
    
#region 公共属性
    /// <summary>
    /// When set to true, new Audios that have the same audio clip as any other Audio, will be ignored
    /// </summary>
    public bool IgnoreDuplicateMusic { get; set; }

    /// <summary>
    /// When set to true, new Audios that have the same audio clip as any other Audio, will be ignored
    /// </summary>
    public bool IgnoreDuplicateSounds { get; set; }


    public float GlobalVolume
    {
        get { return vol; }
        set { vol = value; }
    }

    public float GlobalMusicVolume
    {
        get { return musicVol; }
        set { musicVol = value; }
    }

    public float GlobalSoundsVolume
    {
        get { return soundsVol; }
        set { soundsVol = value; }
    }

    public bool GlobalIsOpenSpeak
    {
        get { return _isOpenSpeakVoice; }
        set { _isOpenSpeakVoice = value; }
    }

    public float GlobalSpeakVolume
    {
        get { return speakVol; }
        set { speakVol = value; }
    }

    public void Init()
    {
        if (!initialized)
        {
            musicAudio = new Dictionary<int, Audio>();
            soundsAudio = new Dictionary<int, Audio>();
            loadingAcb = new Dictionary<string, int>();
            _freeMusicAudio = new Queue<Audio>();
            _freeSoundsAudio = new Queue<Audio>();

            IgnoreDuplicateMusic = false;
            IgnoreDuplicateSounds = false;

            initialized = true;
        }

        //SceneManager.sceneLoaded += OnSceneLoaded;
    }
#endregion

#region 公共方法
public void Release()
    {
        //SceneManager.sceneLoaded -= OnSceneLoaded;
        _LoadedAcbAssetDic.Clear();
        _isAcbLoadedDic.Clear();
    }

    public void RemoveAudio(GameObject go)
    {
        try
        {
            var source = go.GetComponent<CriAtomSourceForAsset>();
            if (source)
            {
                using var e = soundsAudio.GetEnumerator();
                while (e.MoveNext())
                {
                    var audio = e.Current.Value;
                    if (audio.audioSource == source)
                    {
                        audio.Stop();
                        _toBeRemoved.Add(e.Current.Key);
                    }
                }
            }
        }
        catch (Exception e)
        {
            DebugUtil.LogError($"RemoveAudio, {e}");
            throw;
        }
        
    }

    public void PauseAll()
    {
        PauseAllMusic();
        PauseAllSounds();
    }

    public void PauseAllMusic()
    {
        List<int> keys = new List<int>(musicAudio.Keys);
        foreach (int key in keys)
        {
            Audio audio = musicAudio[key];
            audio.Pause();
        }
    }

    public void PauseAllSounds()
    {
        List<int> keys = new List<int>(soundsAudio.Keys);
        foreach (int key in keys)
        {
            Audio audio = soundsAudio[key];
            audio.Pause();
        }
    }

    public void ResumeAll()
    {
        ResumeAllMusic();
        ResumeAllSounds();
    }

    public void ResumeAllMusic()
    {
        if (banMusic)
            return;

        List<int> keys = new List<int>(musicAudio.Keys);
        foreach (int key in keys)
        {
            DebugUtil.Log("audio status: " + musicAudio[key].audioSource.status);
            Audio audio = musicAudio[key];
            audio.Resume();
        }
    }

    public void ResumeAllSounds()
    {
        List<int> keys = new List<int>(soundsAudio.Keys);
        foreach (int key in keys)
        {
            Audio audio = soundsAudio[key];
            audio.Resume();
        }
    }


    public void StopAll(float fadeOutSeconds = -1.0f)
    {
        StopAllMusic(fadeOutSeconds);
        StopAllSounds();
    }

    public void StopAllMusic(float fadeOutSeconds = -1.0f)
    {
        List<int> keys = new List<int>(musicAudio.Keys);
        foreach (int key in keys)
        {
            Audio audio = musicAudio[key];
            if (fadeOutSeconds > 0)
            {
                audio.fadeOutSeconds = fadeOutSeconds;
            }

            audio.Stop();
        }
    }

    public void StopAllSounds()
    {
        List<int> keys = new List<int>(soundsAudio.Keys);
        foreach (int key in keys)
        {
            Audio audio = soundsAudio[key];
            audio.Stop();
        }
    }
    
    public void StopBGM()
    {
        _bgmAudio.Stop();
    }
    
    public void StopSoundById(int soundId)
    {
        if (soundId >= 0)
        {
            List<int> keys = new List<int>(soundsAudio.Keys);
            foreach (int key in keys)
            {
                Audio audio = soundsAudio[key];
                if (audio.audioID == soundId)
                {
                    audio.Stop();
                }
            }
        }
    }

    public void StopMusicById(int soundId)
    {
        if (soundId >= 0)
        {
            List<int> keys = new List<int>(musicAudio.Keys);
            foreach (int key in keys)
            {
                Audio audio = musicAudio[key];
                if (audio.audioID == soundId)
                {
                    audio.Stop();
                }
            }
        }
    }

    public Audio GetAudioByID(AudioType audioType, int id)
    {
        if (audioType == AudioType.MUSIC)
        {
            if (!musicAudio.ContainsKey(id))
            {
                return null;
            }

            return musicAudio[id];
        }
        
        if (audioType == AudioType.SOUND)
        {
            if (!soundsAudio.ContainsKey(id))
            {
                return null;
            }

            return soundsAudio[id];
        }

        return null;
    }
#endregion

#region 播放逻辑
    /// <summary>
    /// 获取播放器挂载节点
    /// </summary>
    private GameObject _GetRootGo(GameObject posObj = null, bool isSound = false)
    {
        if (!isSound)
        {
            if (_bgmAudio == null)
            {
                return _rootGoList[0];
            }
            return _bgmAudio.RootGo;
        }
        if (posObj != null)
        {
            foreach (var kv in _audioDic)
            {
                var go = kv.Key;
                var audio = kv.Value;
                if (audio.PosGo == posObj && _bgmAudio != audio)
                {
                    return go;
                }
            }
        }
        
        for (int i = 0; i < _rootGoList.Count; i++)
        {
            var go = _rootGoList[i];
            if (!IsAudioExist(go))
            {
                return go;
            }
        }

        foreach (var kv in _audioDic)
        {
            var go = kv.Key;
            var audio = kv.Value;
            if (audio.IsStopped && _bgmAudio != audio)
            {
                return go;
            }
        }

        if (isSound)
        {
            var minID = SOUNDS_POOL_MAX_NUM + MUSIC_POOL_MAX_NUM + 1;
            foreach (var kv in soundsAudio)
            {
                var curAudio = kv.Value;
                if (minID == Math.Min(minID, curAudio.PlayID))
                {
                    continue;
                }
                minID = curAudio.PlayID;
                _oldestSound = curAudio;
            }
            return _oldestSound.RootGo;
        }
        
        return null;
    }

    private bool IsAudioExist(GameObject rootGo)
    {
        if (_audioDic.ContainsKey(rootGo))
        {
            return true;
        }

        return false;
    }
    
    public async UniTask<int> PlayMusicCommon(string musicName, string cueName = "", bool loop = true)
    {
        try
        {
            CriAtomAcbAsset au;
            if (!_isAcbLoadedDic.ContainsKey(musicName))
            {
                await CheckIsLoading(musicName);
            }
            //if (AssetManager.Instance.IsAssetPreLoaded(musicName + ".acb"))
            if (_isAcbLoadedDic.ContainsKey(musicName))
            {
                au =  LoadAudio(AudioType.MUSIC, musicName);
            }
            else
            {
                au = await LoadAudioAsync(AudioType.MUSIC, musicName);
            }
        

            if (au != null)
            {
                AudioInfo audioInfo = new AudioInfo()
                {
                    persist = true, 
                    volume = 1, 
                    fadeInValue = 0.3f, 
                    fadeOutValue = 0.3f,
                };
                return PlayMusic(au, loop, null, false, cueName, audioInfo);
            }

            return -1;
        }
        catch (Exception e)
        {
            DebugUtil.LogError($"playMusicCommon, {cueName}, {e}");
            throw;
        }
        
    }

    // public void Update(float deltaTime)
    // {
    //     using (var e = musicAudio.GetEnumerator())
    //     {
    //         while (e.MoveNext())
    //         {
    //             var music = e.Current.Value;
    //             music.Update();
    //             if (!music.audioSource)
    //             {
    //                 _toBeRemoved.Add(e.Current.Key);
    //             }
    //             if (!music.IsPlaying && !music.IsPaused && !music.IsLoading)
    //             {
    //                 _toBeRemoved.Add(e.Current.Key);
    //             }
    //         }
    //
    //         if (_toBeRemoved.Count > 0)
    //         {
    //             for (int i = 0; i < _toBeRemoved.Count; i++)
    //             {
    //                 var audio = musicAudio[_toBeRemoved[i]];
    //                 if (!GetIsArrivePoolLimit(AudioType.MUSIC))
    //                 {
    //                     _freeMusicAudio.Enqueue(audio);
    //                 }
    //                 else
    //                 {
    //                     switch (curClipType)
    //                     {
    //                         case ClipType.AudioClip:
    //                         {
    //                             Object.Destroy(audio.audioSource);
    //                             break;
    //                         }
    //                         case ClipType.CriwareClip:
    //                         {
    //                             if (audio.RootGo && audio.RootGo != initGameObject)
    //                             {
    //                                 Object.Destroy(audio.RootGo);
    //                             }
    //                             Object.Destroy(audio.audioSource);
    //                             break;
    //                         }
    //                         default:
    //                             break;
    //                     }
    //                 }
    //             
    //                 musicAudio.Remove(_toBeRemoved[i]);
    //             }
    //
    //             _toBeRemoved.Clear();
    //         }
    //     }
    //
    //
    //     using (var e1 = soundsAudio.GetEnumerator())
    //     {
    //         // Update sound fx            
    //         while (e1.MoveNext())
    //         {
    //             var sound = e1.Current.Value;
    //             sound.Update();
    //             if (!sound.audioSource)
    //             {
    //                 _toBeRemoved.Add(e1.Current.Key);
    //             }
    //             else if (!sound.IsPlaying && !sound.IsPaused && !sound.IsLoading)
    //             { 
    //                 _toBeRemoved.Add(e1.Current.Key);
    //             }
    //         }
    //
    //         if (_toBeRemoved.Count > 0)
    //         {
    //             for (int i = 0; i < _toBeRemoved.Count; i++)
    //             {
    //                 var audio = soundsAudio[_toBeRemoved[i]];
    //             
    //                 if (!GetIsArrivePoolLimit(AudioType.SOUND))
    //                 {
    //                     _freeSoundsAudio.Enqueue(audio);
    //                 }
    //                 else
    //                 {
    //                     switch (curClipType)
    //                     {
    //                         case ClipType.AudioClip:
    //                         {
    //                             Object.Destroy(audio.audioSource);
    //                             break;
    //                         }
    //                         case ClipType.CriwareClip:
    //                         {
    //                             Object.Destroy(audio.audioSource);
    //                         
    //                             if (audio.RootGo && audio.RootGo != initGameObject) 
    //                             {
    //                                 Object.Destroy(audio.RootGo);
    //                             }
    //                             break;
    //                         }
    //                         default:
    //                             break;
    //                     }
    //                 }
    //             
    //                 soundsAudio.Remove(_toBeRemoved[i]);
    //             }
    //
    //             _toBeRemoved.Clear();
    //         }
    //     }
    //     
    // }

    public void Update(float dt)
    {
        // foreach (var kv in musicAudio)
        // {
        //     var audio = kv.Value;
        //     if (!audio.IsStopped)
        //     {
        //         audio.Update();
        //         _UpdateObjPos(audio);
        //     }
        //     else
        //     {
        //         audio.PosGo = null;
        //     }
        // }
        if (_bgmAudio != null)
        {
            if (!_bgmAudio.IsStopped)
            {
                _bgmAudio.Update();
            }
            else
            {
                _bgmAudio.PosGo = null;
            }
        }
        //if (_albumAudio != null)
        //{
        //    if(!_albumAudio.IsStopped)
        //    {
        //        _albumAudio.Update();
        //    }
        //    else
        //    {
        //        _albumAudio.PosGo = null;
        //    }
        //}
        
        
        foreach (var kv in soundsAudio)
        {
            var audio = kv.Value;
            if (!audio.IsStopped)
            {
                audio.Update();
                _UpdateObjPos(audio);
            }
            else
            {
                audio.PosGo = null;
            }
        }
    }

    private void _UpdateObjPos(Audio audio)
    {
        var rootGo = audio.RootGo;
        var posGo = audio.PosGo;
        if (posGo)
        {
            if (rootGo != posGo)
            {
                rootGo.transform.position = posGo.transform.position;
            }
        }
    }
    
    public void AfterSwitchMainCamera(Camera camera)
    {
        var listener = camera.GetComponent<CriAtomListener>();
        if (!listener)
        {
            camera.gameObject.AddComponent<CriAtomListener>();
        }
    }

    private bool GetIsArrivePoolLimit(AudioType audioType)
    {
        if (audioType == AudioType.MUSIC)
        {
            return musicAudio.Count + _freeMusicAudio.Count >= MUSIC_POOL_MAX_NUM;
        }
        return soundsAudio.Count + _freeSoundsAudio.Count >= SOUNDS_POOL_MAX_NUM;
    }

    public async UniTask<int> PlaySoundCommon(string soundName, string cueName = "", bool isSpeak = false)
    {
        if (!_isAcbLoadedDic.ContainsKey(soundName))
        {
            await CheckIsLoading(soundName);
        }
        
        if (GlobalSoundsVolume <= 0.01 && !isSpeak)
        {
            return -1;
        }
        if (GlobalSpeakVolume <= 0.01 && isSpeak)
        {
            return -1;
        }
        
        try
        {
            switch (curClipType)
            {
                case ClipType.AudioClip:
                {
                    break;
                }
                case ClipType.CriwareClip:
                {
                    CriAtomAcbAsset acb;
                    //if (AssetManager.Instance.IsAssetPreLoaded(soundName + ".acb"))
                    if (_isAcbLoadedDic.ContainsKey(soundName))
                    {
                        acb = LoadAudio(AudioType.SOUND, soundName);
                    }
                    else
                    {
                        acb = await LoadAudioAsync(AudioType.SOUND, soundName);
                    }
                    
                    if (acb != null)
                    {
                        return PlaySound(acb, GlobalVolume, false, null, isSpeak, false, cueName);
                    }
                    break;
                }
                default:
                    break;
            }

            DebugUtil.LogError("==== audio null!!! ====");
        }
        catch (Exception e)
        {
            DebugUtil.LogError("{0}.PlaySound:{1} error:{2}", GetType(), soundName, e.Message);
        }

        return -1;
    }

    public void SetMusicEnable(bool isEnable)
    {
        GlobalMusicVolume = isEnable ? 1 : 0;
    }

    public void SetSoundEnable(bool isEnable)
    {
        GlobalSoundsVolume = isEnable ? 1 : 0;
    }

    public async UniTask<int> PlayMusicCommon(string musicName, GameObject posObj, string cueName = "", bool loop = true)
    {
        try
        {
            CriAtomAcbAsset au;
            if (!_isAcbLoadedDic.ContainsKey(musicName))
            {
                await CheckIsLoading(musicName);
            }
            //if (AssetManager.Instance.IsAssetPreLoaded(musicName + ".acb"))
            if (!_isAcbLoadedDic.ContainsKey(musicName))
            {
                au = await LoadAudioAsync(AudioType.MUSIC, musicName);
            }
            else
            {
                au = LoadAudio(AudioType.MUSIC, musicName);
            }

            if (au != null)
            {
                AudioInfo audioInfo = new AudioInfo()
                {
                    persist = true, 
                    volume = 1, 
                    fadeInValue = 0.3f, 
                    fadeOutValue = 0.3f,
                };
                return PlayMusic(au, loop, posObj, true, cueName, audioInfo);
            }

            return -1;
        }
        catch (Exception e)
        {
            DebugUtil.LogError($"PlayMusicCommon, cueName = {cueName}, {e}");
            throw;
        }
        
    }

    public async UniTask<int> PlaySoundCommon(string soundName, GameObject posObj, string cueName, bool is3D = false, 
        Vector3 pos = new Vector3(), bool isSpeak = false)
    {
        if (!_isAcbLoadedDic.ContainsKey(soundName))
        {
            await CheckIsLoading(soundName);
        }
        
        if (GlobalSoundsVolume <= 0.01 && !isSpeak)
        {
            return -1;
        }
        if (GlobalSpeakVolume <= 0.01 && isSpeak)
        {
            return -1;
        }
        
        try
        {
            switch (curClipType)
            {
                case ClipType.AudioClip:
                {
                    break;
                }
                case ClipType.CriwareClip:
                {
                    CriAtomAcbAsset acb;
                    
                    //if (AssetManager.Instance.IsAssetPreLoaded(soundName + ".acb"))
                    if (_isAcbLoadedDic.ContainsKey(soundName))
                    {
                        acb = LoadAudio(AudioType.SOUND, soundName);
                    }
                    else
                    {
                        acb = await LoadAudioAsync(AudioType.SOUND, soundName);
                    }
                    if (acb != null)
                    {
                        return PlaySound(acb, GlobalVolume, false, posObj, isSpeak, is3D, cueName, pos);
                    }
                    
                    break;
                }
                default:
                    break;
            }

            DebugUtil.LogError("==== audio null!!! ====");
        }
        catch (Exception e)
        {
            DebugUtil.LogError("{0}.PlaySound:{1} error:{2}", GetType(), soundName, e.Message);
        }

        return -1;
    }
   
    private async UniTask CheckIsLoading(string audioName)
    {
        while (loadingAcb.ContainsKey(audioName))
        {
            await UniTask.NextFrame();
        }
    }

    private int PlaySoundCommonImmediately(string soundName, GameObject posObj, string cueName, bool is3D = false,
        Vector3 pos = new Vector3(), bool isSpeak = false)
    {
        if (!_isAcbLoadedDic.ContainsKey(soundName))
        {
            DebugUtil.LogError($"--- acb资源没有完成加载，请检查！！！ acbName: {soundName} ---");
            return -1;
        }
        
        if (GlobalSoundsVolume <= 0.01 && !isSpeak)
        {
            return -1;
        }
        if (GlobalSpeakVolume <= 0.01 && isSpeak)
        {
            return -1;
        }

        try
        {
            var acb = LoadAudio(AudioType.SOUND, soundName);
            return PlaySound(acb, GlobalVolume, false, posObj, isSpeak, is3D, cueName, pos);
        }
        catch (Exception e)
        {
            DebugUtil.LogError(e);
            throw;
        }
        
    }
    
    private int PlaySoundCommonImmediately(string soundName, string cueName, bool isSpeak = false)
    {
        if (!_isAcbLoadedDic.ContainsKey(soundName))
        {
            DebugUtil.LogError($"--- acb资源没有完成加载，请检查！！！ acbName: {soundName} ---");
            return -1;
        }
        
        if (GlobalSoundsVolume <= 0.01 && !isSpeak)
        {
            return -1;
        }
        if (GlobalSpeakVolume <= 0.01 && isSpeak)
        {
            return -1;
        }

        try
        {
            var acb = LoadAudio(AudioType.SOUND, soundName);
            return PlaySound(acb, GlobalVolume, false, null, isSpeak, false, cueName);
        }
        catch (Exception e)
        {
            DebugUtil.LogError(e);
            throw;
        }
        
    }

    /// <summary>
    /// 播放音乐
    /// </summary>
    /// <param name="acbAsset"></param> acbAsset
    /// <param name="loop"></param> 是否循环
    /// <param name="sourceTransform"></param> 挂载的trans
    /// <param name="is3D"></param> 是否3D音效
    /// <param name="cueName"></param> 播放的Cue里面哪个音源
    /// <param name="audioInfo"></param> 结构体，包含淡入淡出的时间
    /// <returns></returns>
    private int PlayMusic(CriAtomAcbAsset acbAsset, bool loop, GameObject posGo,
        bool is3D, string cueName, AudioInfo audioInfo)
    {
        if (acbAsset == null)
        {
            DebugUtil.LogError("Sound Manager: Audio clip is null, cannot play music", acbAsset);
        }

        try
        {
            if (IgnoreDuplicateMusic)
            {
                List<int> keys = new List<int>(musicAudio.Keys);
                foreach (int key in keys)
                {
                    if (musicAudio[key].audioSource.Cue.AcbAsset.name == acbAsset.name)
                    {
                        return musicAudio[key].audioID;
                    }
                }
            }

            // Stop all current music playing
            //StopAllMusic(audioInfo.fadeOutValue);

            // Create the audioSource
            Audio audio;
            GameObject rootGo;
            if (_bgmAudio == null)
            {
                rootGo = _GetRootGo(posGo);
            }
            else
            {
                rootGo = _bgmAudio.RootGo;
            }
            if (!posGo)
            {
                posGo = initGameObject;
            }

            if (_bgmAudio != null)
            {
                //audio = _bgmAudio;
                _bgmAudio.Stop();
                _bgmAudio.SetAcbAsset(acbAsset);//设置音频资源
                _bgmAudio.audioType = AudioBase.AudioType.Music;
                _bgmAudio.SetVolume(audioInfo.volume);
                _bgmAudio.Play(cueName, true);
            }
            else//创建新的背景音乐播放器，此时构造函数中将检查频谱分析器的绑定
            {
                rootGo.transform.SetParent(initGameObject.transform);
                audio = new Audio(Audio.AudioType.Music, acbAsset, loop, posGo, rootGo, is3D, cueName, audioInfo);
                rootGo.name = "Music" + audio.audioID;
                _audioDic.TryAdd(rootGo, audio);
                _bgmAudio = audio;
            }
            rootGo.transform.position = posGo.transform.position;

            // Add it to music list
            musicAudio.TryAdd(_bgmAudio.audioID, _bgmAudio);

            if (banMusic)
            {
                _bgmAudio.Pause();
            }

            return _bgmAudio.audioID;
        }
        catch (Exception e)
        {
            DebugUtil.LogError(e);
            throw;
        }
    }  
    private int PlaySound(CriAtomAcbAsset acbAsset, float volume, bool loop, GameObject posGo, 
        bool isSpeak = false, bool is3D = false, string cueName = "", Vector3 pos = new Vector3(), float pitch = 1.0f)
    {
        if (acbAsset == null)
        {
            DebugUtil.LogError("Sound Manager: Audio clip is null, cannot play music");
        }

        try
        {
            if (banSound)
            {
                return -1;
            }

            // if (IgnoreDuplicateSounds)
            // {
            //     List<int> keys = new List<int>(soundsAudio.Keys);
            //     foreach (var key in keys)
            //     {
            //         if (soundsAudio.ContainsKey(key) && soundsAudio[key].audioSource.Cue.AcbAsset.name.Equals(acbAsset.name) )
            //             return soundsAudio[key].audioID;
            //     }
            // }

#if UNITY_EDITOR || UNITY_IOS || UNITY_ANDROID
            // Create the audioSource
            Audio audio;
            AudioInfo audioInfo = new AudioInfo()
            {
                persist = false, 
                volume = volume, 
                fadeInValue = 0f, 
                fadeOutValue = 0f,
                isSpeak = isSpeak
            };
        
            GameObject rootGo = _GetRootGo(posGo, true);
            if (!posGo)
            {
                rootGo.transform.position = pos;
                posGo = rootGo;
            }
            else
            {
                rootGo.transform.position = posGo.transform.position;
            }
            
            if (IsAudioExist(rootGo))
            {
                audio = _audioDic[rootGo];
                audio.SetAcbAsset(acbAsset);
                audio.audioType = AudioBase.AudioType.Sound;
                audio.SetIs3D(is3D);
                audio.SetVolume(audioInfo.volume);
                audio.SetIsSpeak(isSpeak);
                audio.Play(cueName);
                // if (_oldestSound == audio)
                // {
                //     _UpdateOldestAudio(audio.PlayID);
                // }
            }
            else
            {
                audio = new Audio(AudioBase.AudioType.Sound, acbAsset, loop, posGo, rootGo, is3D, cueName, audioInfo);
                audio.SetIsSpeak(isSpeak);
                rootGo.name = "sound" + audio.audioID;
                _audioDic.TryAdd(rootGo, audio);
            }
#if UNITY_EDITOR
                //go.name += "_"+ audio.audioID;
#endif

            audio.SetPitch(pitch);
            // Add it to music list
            soundsAudio.TryAdd(audio.audioID, audio);
            return audio.audioID;
        
#else
            return -1;
#endif
        }
        catch (Exception e)
        {
            DebugUtil.LogError($"PlaySound, cueName: {cueName}, {e}");
            throw;
        }
        
    }

    private void _UpdateOldestAudio(int minID)
    {
        foreach (var kv in soundsAudio)
        {
            var curAudio = kv.Value;
            if (minID == Math.Min(minID, curAudio.PlayID))
            {
                continue;
            }
            minID = curAudio.PlayID;
            _oldestSound = curAudio;
        }
    }

    private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
    {
        try
        {
            List<int> keys;
            // Stop and remove all non-persistent music audio
            keys = new List<int>(musicAudio.Keys);

            switch (curClipType)
            {
                case ClipType.AudioClip:
                {
                    foreach (var key in keys)
                    {
                        if (musicAudio.ContainsKey(key))
                        {
                            var music = musicAudio[key];
                            if (!music.persist && music.activated)
                            {
                                Object.Destroy(music.audioSource);
                                musicAudio.Remove(key);
                            }
                        }
                    }

                    // Stop sound fx
                    keys = new List<int>(soundsAudio.Keys);
                    foreach (var key in keys)
                    {
                        if (soundsAudio.ContainsKey(key))
                        {
                            var sound = soundsAudio[key];
                            Object.Destroy(sound.audioSource);
                            soundsAudio.Remove(key);
                        }
                    }

                    break;
                }

                case ClipType.CriwareClip:
                {
                    foreach (var key in keys)
                    {
                        if (musicAudio.ContainsKey(key))
                        {
                            var music = musicAudio[key];
                            if (!music.persist && music.activated)
                            {
                                Object.Destroy(music.audioSource);
                                musicAudio.Remove(key);
                            }
                        }
                    }

                    // Stop sound fx
                    keys = new List<int>(soundsAudio.Keys);
                    foreach (var key in keys)
                    {
                        if (soundsAudio.ContainsKey(key))
                        {
                            var sound = soundsAudio[key];
                            Object.Destroy(sound.audioSource);
                            soundsAudio.Remove(key);
                        }
                    }
                    break;
                }

                default:
                    break;
            }
        }
        catch (Exception e)
        {
            DebugUtil.LogError(e);
            throw;
        }
        
    }
    
    //异步加载音频
    private async UniTask<CriAtomAcbAsset> LoadAudioAsync(AudioType type, string audioName, bool is3D = false)
    {
        try
        {
            loadingAcb.Add(audioName, 1);
        
            string acfName = audioName + ".acf";
            await LoadAcfAsync(type, acfName);

            string acbName = audioName + ".acb";
            CriAtomAcbAsset acbAsset = await AssetManager.Instance.LoadAssetAsync<CriAtomAcbAsset>(acbName);
            acbAsset.OnLoaded += (acb) =>
            {
                loadingAcb.Remove(audioName);

                _isAcbLoadedDic.TryAdd(audioName, true);
                _LoadedAcbAssetDic.TryAdd(audioName, acb);
                var cueRef = new CriAtomCueReference(acb, 0);
                AudioCriware.CueReferenceDic.TryAdd(acb, cueRef);
            };
            acbAsset.LoadImmediate();
            // loadingAcb.Remove(audioName);
            //
            // _isAcbLoadedDic.TryAdd(audioName, true);
            // _LoadedAcbAssetDic.TryAdd(audioName, acbAsset);
            // var cueRef = new CriAtomCueReference(acbAsset, 0);
            // CueReferenceDic.TryAdd(acbAsset, cueRef);
            
            return acbAsset;
        }
        catch (Exception e)
        {
            DebugUtil.LogError($"LoadAudioAsync failed!!!, audioName:{audioName}, {e}");
            throw;
        }
    }

    private void _OnAcbLoaded()
    {
        
    }
    
    //同步加载音频，需要已预加载资源
    private CriAtomAcbAsset LoadAudio(AudioType type, string audioName, bool is3D = false)
    {
        // string acfName = audioName + ".acf";
        // LoadAcf(type, acfName);
        
        //string acbName = audioName + ".acb";
        //CriAtomAcbAsset acbAsset = AssetManager.Instance.LoadAsset<CriAtomAcbAsset>(acbName);
        if (_LoadedAcbAssetDic.TryGetValue(audioName, out var acbAsset))
        {
            return acbAsset;
        }
        return null;
    }

    private async UniTask<CriAtomAcfAsset> LoadAcfAsync(AudioType type, string audioName, bool is3D = false)
    {
        CriAtomAcfAsset acfAsset = await AssetManager.Instance.LoadAssetAsync<CriAtomAcfAsset>(audioName);
        acfAsset.Register();
        
        return acfAsset;
    }
    
    private CriAtomAcfAsset LoadAcf(AudioType type, string audioName, bool is3D = false)
    {
        CriAtomAcfAsset acfAsset = AssetManager.Instance.LoadAsset<CriAtomAcfAsset>(audioName);
        acfAsset.Register();
        
        return acfAsset;
    }

    private bool CheckIsLoadedAcb(string audioName)
    {
        return _LoadedAcbAssetDic.ContainsKey(audioName);
    }

    private bool CheckAudioIsPlayable(DataAudio audioData)
    {
        if (audioData == null)
        {
            return false;
        }

        if (audioData.IsSpeak)
        {
            return _isOpenSpeakVoice;
        }
        return true;
    }

    //外部接口
    public async UniTask<int> PlayAudio(string key, AudioCriManager.EPlayType type, GameObject posObj = null)
    {
        
        //全局播放，挂到Audio物体上
        var audioData = TableManager.Instance.Tables.Audios.GetByKey(key);
        if (audioData == null)
        {
            DebugUtil.LogError("==== 播放的音频不存在！！！音频Key: {0}", key);
            return -1;
        }
        if (!CheckAudioIsPlayable(audioData))
        {
            return -1;
        }

        var audioName = audioData.Path;//Framework.Constants.AUDIO_MUSIC_PATH + audioData.Path;
    
        if (!posObj)
        {
            int audioID;
            switch (audioData.Type)
            {
                case (cfg.AudioCfg.AudioType.Sound):
                {
                    if (CheckIsLoadedAcb(audioName))
                    {
                        audioID = PlaySoundCommonImmediately(audioName, audioData.CueName, audioData.IsSpeak);
                    }
                    else
                    {
                        audioID = await PlaySoundCommon(audioName, audioData.CueName, audioData.IsSpeak);
                    }
                    
                    return audioID;
                }
                case (cfg.AudioCfg.AudioType.Music):
                {
                    audioID = await PlayMusicCommon(audioName,  audioData.CueName);
                    return audioID;
                }
                default:
                    break;
            }
            return -1;
        }
    
        //定点播放
        switch (audioData.Type)
        {
            case (cfg.AudioCfg.AudioType.Sound):
            {
                int audioID = await PlaySoundCommon(audioName, posObj, audioData.CueName, audioData.IsSpeak);
                return audioID;
            }
            case (cfg.AudioCfg.AudioType.Music):
            {
                int audioID = await PlayMusicCommon(audioName,  posObj, audioData.CueName);
                return audioID;
            }
            default:
                break;
        }

        return -1;
        
    }
    
    public async UniTask<int> PlayAudio(string key, AudioCriManager.EPlayType type, Vector3 pos)
    {
        //全局播放，挂到Audio物体上
        var audioData = TableManager.Instance.Tables.Audios.GetByKey(key);
        if (audioData == null)
        {
            DebugUtil.LogError("==== 播放的音频不存在！！！音频Key: {0}", key);
            return -1;
        }
        if (!CheckAudioIsPlayable(audioData))
        {
            return -1;
        }

        var audioName = audioData.Path;
        
        //定点播放
        // var go = new GameObject();
        // go.transform.position = pos;
        switch (audioData.Type)
        {
            case (cfg.AudioCfg.AudioType.Sound):
            {
                int audioID;
                if (CheckIsLoadedAcb(audioName))
                {
                    audioID = PlaySoundCommonImmediately(audioName, null, audioData.CueName, true, pos, audioData.IsSpeak);
                }
                else
                {
                    audioID = await PlaySoundCommon(audioName, null, audioData.CueName, true, pos, audioData.IsSpeak);
                }

                return audioID;
            }
            case (cfg.AudioCfg.AudioType.Music):
            {
                int audioID = await PlayMusicCommon(audioName,  null, audioData.CueName, true);
                return audioID;
            }
            default:
                break;
        }

        return -1;
    }

    public async UniTask<int> PlayAudio(int ID, AudioCriManager.EPlayType type, Vector3 pos)
    {
        //全局播放，挂到Audio物体上
        var audioData = TableManager.Instance.Tables.Audios.GetByID(ID);
        if (audioData == null)
        {
            DebugUtil.LogError("==== 播放的音频不存在！！！音频ID: {0}", ID);
            return -1;
        }
        if (!CheckAudioIsPlayable(audioData))
        {
            return -1;
        }


        var audioName = audioData.Path;//Framework.Constants.AUDIO_MUSIC_PATH;// + audioData.Path;
        
        //定点播放
        switch (audioData.Type)
        {
            case (cfg.AudioCfg.AudioType.Sound):
            {
                int audioID;
                if (CheckIsLoadedAcb(audioName))
                {
                    audioID = PlaySoundCommonImmediately(audioName, null, audioData.CueName, true, pos, audioData.IsSpeak);
                }
                else
                {
                    audioID = await PlaySoundCommon(audioName, null, audioData.CueName, true, pos, audioData.IsSpeak);
                }
                return audioID;
            }
            case (cfg.AudioCfg.AudioType.Music):
            {
                int audioID = await PlayMusicCommon(audioName,  null, audioData.CueName, true);
                return audioID;
            }
            default:
                break;
        }

        return -1;
        
    }
    
    public async UniTask<int> PlayAudio(int ID, AudioCriManager.EPlayType type, GameObject posObj = null)
    {
        //全局播放，挂到Audio物体上
        var audioData = TableManager.Instance.Tables.Audios.GetByID(ID);
        if (audioData == null)
        {
            DebugUtil.LogError("==== 播放的音频不存在！！！音频Key: {0}", ID);
            return -1;
        }
        if (!CheckAudioIsPlayable(audioData))
        {
            return -1;
        }


        var audioName = audioData.Path;//Constants.AUDIO_MUSIC_PATH + audioData.Path;
        int audioID = -1;
        if (!posObj)
        {
            switch (audioData.Type)
            {
                case (cfg.AudioCfg.AudioType.Sound):
                {
                    if (CheckIsLoadedAcb(audioName))
                    {
                        audioID = PlaySoundCommonImmediately(audioName, audioData.CueName, audioData.IsSpeak);
                    }
                    else
                    {
                        audioID = await PlaySoundCommon(audioName, audioData.CueName, audioData.IsSpeak);
                    }
                    break;
                }
                case (cfg.AudioCfg.AudioType.Music):
                {
                    audioID = await PlayMusicCommon(audioName, audioData.CueName);
                    break;
                }
                default:
                    break;
            }

            return audioID;
        }

        //定点播放
        switch (audioData.Type)
        {
            case (cfg.AudioCfg.AudioType.Sound):
            {
                audioID = await PlaySoundCommon(audioName, posObj, audioData.CueName, audioData.IsSpeak);
                break;
            }
            case (cfg.AudioCfg.AudioType.Music):
            {
                audioID = await PlayMusicCommon(audioName, posObj, audioData.CueName);
                break;
            }
        }

        return audioID;
    }
    

    #endregion

    //在播放之前注册
    public CriAtomExOutputAnalyzer RegisterAnalyzer()//CriAtomExOutputAnalyzer s
    {
        IsAnalyzer = true;
        if (analyzer == null)
        {
            analyzer = new(NewAnalyzerConfig());
        }
        return analyzer;
        //analyzer = s;
    }

    public void UnregisterAnalyzer()//CriAtomExOutputAnalyzer s
    {
        //s.DetachExPlayer();
        IsAnalyzer = false;
        //analyzer = null;
    }

    /// <summary>
    /// 获取音频输出分析器配置
    /// </summary>
    /// <returns></returns>
    private CriAtomExOutputAnalyzer.Config NewAnalyzerConfig()
    {
        CriAtomExOutputAnalyzer.Config config = new()
        {
            enableSpectrumAnalyzer = true, // 开启频谱分析
            numSpectrumAnalyzerBands = 16, // 频谱分析数量SPECTRUM_SAMPLES_NUMBER
        };

        return config;
    }
}

#region Audio类
public struct AudioInfo
{
    public bool persist;
    public float volume;
    public float fadeInValue;
    public float fadeOutValue;
    public bool isSpeak;
}
public class Audio : AudioCriware
{
    
    public Audio(AudioType audioType, CriAtomAcbAsset acb, bool loop, GameObject posGo, GameObject rootGo, 
        bool is3D, string cueName, AudioInfo audioInfo): 
        base(acb, loop, posGo, rootGo, is3D, cueName, audioInfo)
    {
        this.audioType = audioType;
        DebugUtil.Log("音频源创建成功: " + cueName);

        OnAcbLoaded(acb, cueName, loop, is3D);
    }

    protected override void AttachAnalyzer()
    {
        if (AudioManager.Instance.AudioMgrObj.IsAnalyzer && audioType == AudioType.Music)//将音频源挂到分析器上
        {
            DebugUtil.Log("音频源挂到分析器上: " + (AudioManager.Instance.AudioMgrObj.analyzer != null));
            audioSource.AttachToAnalyzer(AudioManager.Instance.AudioMgrObj.analyzer);
        }
    }
}

#endregion