using System;
using Cysharp.Threading.Tasks;
using PhxhSDK;
using UnityEngine;
using UnityEngine.Audio;

public class AudioManager: Singlenton<AudioManager>, IStart, IInitable, IUpdatable
{
    private AudioUnityManager _audioMgrObj = new();

    public static bool DisableAudio = false;

    private bool isPlayingAlbum = false;
    public bool IsPlayingAlbum
    {
        get
        {
            return isPlayingAlbum;
        }
        set
        {
            isPlayingAlbum = value;
        }
    }
    public bool IsPlayingBGM { get; set; }

    public AudioUnityManager AudioMgrObj
    {
        get { return _audioMgrObj; }
    }

    private void AfterSwitchCamera(bool isRegister = true)
    {
        if (isRegister)
        {
            CameraManager.Instance.AfterSwitchMainCamera += _audioMgrObj.AfterSwitchMainCamera;
        }
        else
        {
            CameraManager.Instance.AfterSwitchMainCamera -= _audioMgrObj.AfterSwitchMainCamera;
        }
        
    }

    public void Init()
    {
        _audioMgrObj.Init();
        AfterSwitchCamera();
    }
    
    public void Release()
    {
        _audioMgrObj.Release();
        AfterSwitchCamera(false);
    }
    
    public void Start()
    {
        _audioMgrObj.Start();
    }
    
    public void Update(float dt)
    {
        _audioMgrObj.Update(dt);
    }
    /// <summary>
    /// 全局总音量 - 直接访问 AudioVolumeSettings
    /// </summary>
    public float GlobalVolume
    {
        get { return AudioVolumeSettings.Instance.GlobalVolume; }
        set { AudioVolumeSettings.Instance.GlobalVolume = value; }
    }

    /// <summary>
    /// 音乐音量 - 直接访问 AudioVolumeSettings
    /// </summary>
    public float GlobalMusicVolume
    {
        get { return AudioVolumeSettings.Instance.MusicVolume; }
        set { AudioVolumeSettings.Instance.MusicVolume = value; }
    }

    /// <summary>
    /// 音效音量 - 直接访问 AudioVolumeSettings
    /// </summary>
    public float GlobalSoundsVolume
    {
        get { return AudioVolumeSettings.Instance.SoundVolume; }
        set { AudioVolumeSettings.Instance.SoundVolume = value; }
    }

    /// <summary>
    /// 语音开关 - 保留在 AudioUnityManager
    /// </summary>
    public bool GlobalIsSpeakOpen
    {
        get { return _audioMgrObj.GlobalIsOpenSpeak; }
        set { _audioMgrObj.GlobalIsOpenSpeak = value; }
    }

    /// <summary>
    /// 语音音量 - 直接访问 AudioVolumeSettings
    /// </summary>
    public float GlobalSpeakVolume
    {
        get { return AudioVolumeSettings.Instance.SpeakVolume; }
        set { AudioVolumeSettings.Instance.SpeakVolume = value; }
    }
        
    public void SetMusicEnable(bool isEnable)
    {
        GlobalMusicVolume = isEnable ? 1 : 0;
    }

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

    public async UniTask<float> GetClipLength(string key)
    {
        return await _audioMgrObj.GetClipLength(key);
    }

    #region 流式播放

    public int PlayAudio(string key, PhxhSDK.EAudioType type = PhxhSDK.EAudioType.Sound, 
        GameObject posObj = null, bool loop = false, int priority = AudioConstant.DefaultPriority, bool isFade = false)
    {
        if (DisableAudio) 
            return -1;
            
        if (type == PhxhSDK.EAudioType.Music)
        {
            IsPlayingAlbum = false;
            IsPlayingBGM = false;
        }
        return _audioMgrObj.PlayAudio(key, type, posObj, loop, priority, isFade);
    }
    
    public int PlayAudio(string key, Vector3 pos, PhxhSDK.EAudioType type = PhxhSDK.EAudioType.Sound, bool loop = false,
        int priority = AudioConstant.DefaultPriority, bool isFade = false)
    {
        if (DisableAudio) 
            return -1;
            
        if (type == PhxhSDK.EAudioType.Music)
        {
            IsPlayingAlbum = false;
            IsPlayingBGM = false;
        }
        return _audioMgrObj.PlayAudio(key, type, pos, loop, priority, isFade);
    }

    #endregion

    public void StopByID(int id)
    {
        if (DisableAudio) 
            return;

        _audioMgrObj.StopByID(id);
    }
    
    public void StopWithFadeByID(int id, float fadeOutTime = 1f)
    {
        if (DisableAudio) return;
        _audioMgrObj.StopWithFadeByID(id, fadeOutTime);
    }

    public void StopMusicByID(int id)
    {
        if (DisableAudio) return;
        _audioMgrObj.StopMusicByID(id);
    }

    public void StopSoundByID(int id)
    {
        if (DisableAudio) return;
        _audioMgrObj.StopSoundByID(id);
    }

    public void PauseBackgroundMusic()
    {
        _audioMgrObj?.StopAllMusic();
    }

    /// <summary>
    /// 暂停所有音效
    /// </summary>
    public void PauseAllSound()
    {
        _audioMgrObj?.PauseAllSound();
    }

    public void ResumeAllSound()
    {
        _audioMgrObj?.ResumeAllSound();
    }
    public void ResumeBackgroundMusic()
    {
        _audioMgrObj?.ResumeAllMusic();
    }

    /// <summary>
    /// 停止语音
    /// </summary>
    public void StopAllSpeaks()
    {
        _audioMgrObj?.StopAllSpeaks();
    }

    public void StopAllMusic()
    {
        IsPlayingAlbum = false;
        IsPlayingBGM = false;
        _audioMgrObj?.StopAllMusic();       
    }

    public void StopAll()
    {
        IsPlayingAlbum = false;
        IsPlayingBGM = false;
        _audioMgrObj.StopAll();
    }

    public void GetSpectrumData(int id, float[] spectrumsShow, float[] spectrumsData)
    {
        AudioPlayer audioInst = _audioMgrObj.GetAudioByID(id);
        if (null == audioInst)
        {
            for (int i = 0; i < spectrumsShow.Length; ++i)
            {
                spectrumsShow[i] = 0f;
            }

            return;
        }

        audioInst.GetSpectrumData(spectrumsData);
        int n = spectrumsData.Length / spectrumsShow.Length;
        for (int i = 0; i < spectrumsShow.Length; ++i)
        {
            float value = 0f;
            for (int j = 0; j < n; ++j)
            {
                value += spectrumsData[i * n + j];
            }

            value = Mathf.Log10(Mathf.Log(i + 2f, 2f) * value * (i * i + 1) * 9 + 1);
            spectrumsShow[i] = value;
        }
    }

    /// <summary>
    /// 通过ID获取播放对象
    /// </summary>
    public AudioPlayer GetAudioByID(int id)
    {
        if (DisableAudio) return null;
        return _audioMgrObj.GetAudioByID(id);
    }

    public AudioPlayer GetStoryAudioInst(PhxhSDK.EAudioType eAudioType = PhxhSDK.EAudioType.Sound)
    {
        return _audioMgrObj.GetStoryAudioInst(eAudioType);
    }

    public void ReleaseStoryAudios()
    {
        _audioMgrObj.ReleaseStoryAudios();
    }

    public void PlayByKey(int audioID, string key, bool isFade = false)
    {
        _audioMgrObj.PlayByKey(audioID, key, isFade);
    }
    
    public void PlayByKey(int audioID, string key, float fadeInTime)
    {
        _audioMgrObj.PlayByKey(audioID, key, true, fadeInTime);
    }
    
    public void PlayByKey(int audioID, string key, float fadeInTime, float targetVolume)
    {
        _audioMgrObj.PlayByKey(audioID, key, fadeInTime, targetVolume);
    }
    
    public int PlayByKey(string key, bool isFade = false, float fadeInTime = 4f)
    {
        return _audioMgrObj.PlayAudio(key, PhxhSDK.EAudioType.Music, null, true, AudioConstant.DefaultPriority,
            isFade, fadeInTime);
    }
    public void ReleaseAllAudios()
    {
        _audioMgrObj.ReleaseAllAudios();
    }

    /// <summary>
    /// 通过音频ID获取音频对象
    /// </summary>
    /// <param name="audioID"></param>
    /// <returns></returns>
    public AudioPlayer GetSoundByAudioID(int audioID)
    {
        return _audioMgrObj.GetSoundByAudioID(audioID);
    }

    public void InitLimit(int c0, int c1, int c2)
    {
        AudioMgrObj.InitLimit(c0, c1, c2);
    }

    public void SetGlobalListenerFollow(bool isActive)
    {
        if(isActive)
            AudioMgrObj.EnterFollowState();
        else
            AudioMgrObj.ExitFollowState();
    }
}