using asap.core;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace game
{
    public class PinballSceneController : MonoBehaviour
    {
        #region 数据相关
        private EventPinballDataManager m_DataManager;
        #endregion

        #region 新手相关
        [Header("新手相关设置")]
        [SerializeField] public SpriteRenderer FiringPin;

        private void HideFiringPin(EventPinballHideFiringPinData data)
        {
            if (FiringPin != null)
            {
                if (FiringPin.gameObject.activeSelf == true)
                {
                    FiringPin.gameObject.SetActive(false);
                }
            }
        }

        private void ShowFiringPin(EventPinballShowFiringPinData data)
        {
            if (FiringPin != null)
            {
                if (FiringPin.gameObject.activeSelf == false)
                {
                    FiringPin.gameObject.SetActive(true);
                }
            }
        }
        #endregion

        #region 动画相关
        public Transform IconPinball;
        [Header("动画相关设置")]
        [SerializeField] private Animation m_ArrowBreathAnim;
        [SerializeField] private List<GameObject> m_HideArrowGameObjectList = new List<GameObject>();
        public void PlayArrowBreathAnim(EventPinballPlayArrowBreathAnimData data)
        {
            m_ArrowBreathAnim.Play();
        }
        public void HideArrowGameObjectList(EventPinballStopArrowBreathAnimData data)
        {
            m_ArrowBreathAnim.Stop();
            foreach (var item in m_HideArrowGameObjectList)
            {
                item.SetActive(false);
            }
        }

        [SerializeField] private string m_LightOnAnimName;
        [SerializeField] private float m_LightOnAnimTime;
        [SerializeField] private Animator m_LightOnAnim;
        public void PlayLightOnAnim(EventPinballPlayLightOnAnimData data)
        {
            m_LightOnAnim.gameObject.SetActive(true);
            m_LightOnAnim.Play(m_LightOnAnimName);
            this.StartCoroutine(StopLightOnAnim());
        }
        private IEnumerator StopLightOnAnim()
        {
            yield return new WaitForSeconds(m_LightOnAnimTime);
            m_LightOnAnim.gameObject.SetActive(false);
            //FishingPinballAct.Publish(new EventPinballRewardUpdateData()
            //{
            //    Scores = m_DataManager.TemporaryScore
            //});
            //FishingPinballAct.Publish<EventPinballStopLightOnAnimData>(new EventPinballStopLightOnAnimData());
        }
        #endregion

        #region 能量箭头相关
        [SerializeField] private List<SpriteRenderer> m_EnergyArrowList = new List<SpriteRenderer>();
        [SerializeField] private Color m_EnergyArrowColorBright = Color.white;
        [SerializeField] private Color m_EnergyArrowColorDark = Color.black;
        private float m_RestoreIntervalTime = 0.1f;
        public void UpdateEnergyArrowList(EventPinballEnergyArrowData data)
        {
            if (data == null) return;

            int count = m_EnergyArrowList.Count;
            float step = 1.0f / count;
            int index = (int)Mathf.Ceil(data.Energy / step);

            for (int i = 0; i < count; ++i)
            {
                SpriteRenderer spriteRenderer = m_EnergyArrowList[i];
                if (i < index)
                {
                    spriteRenderer.color = m_EnergyArrowColorBright;
                }
                else
                {
                    spriteRenderer.color = m_EnergyArrowColorDark;
                }
            }
        }
        public void RestoreEnergyArrowList(EventPinballEnergyArrowRestoreData data)
        {
            if (data == null) return;
            this.StartCoroutine(RestoreEnergyArrowListToDark());
        }
        public IEnumerator RestoreEnergyArrowListToDark()
        {
            int count = m_EnergyArrowList.Count;
            int brightIndex = -1;
            for (int i = 0; i < count; i++)
            {
                SpriteRenderer spriteRenderer = m_EnergyArrowList[i];
                if (spriteRenderer.color == m_EnergyArrowColorBright)
                {
                    brightIndex = i;
                }
            }

            if (brightIndex >= 0)
            {
                for (int i = brightIndex; i >= 0; i--)
                {
                    yield return new WaitForSeconds(m_RestoreIntervalTime);
                    SpriteRenderer spriteRenderer = m_EnergyArrowList[i];
                    spriteRenderer.color = m_EnergyArrowColorDark;
                }
            }
        }
        #endregion

        #region 圆形进度相关
        [Header("奖励圆盘特效&动画相关设置")]
        [SerializeField] private int m_ResponseNumber = 10;     // 相应次数
        public List<PinballCircularProgress> m_CircularProgressList = new List<PinballCircularProgress>();
        public void UpdateBonusCircularProgress(EventPinballUpdateBonusCircularProgress data)
        {
            if (m_DataManager == null) return;

            float progress = m_DataManager.GetBonusResponseRatio();
            foreach (var item in m_CircularProgressList)
            {
                item.SetProgress(progress);
            }
        }

        public List<Transform> m_CircularAnimList = new List<Transform>();
        public float m_CircularAnimRotationalSpeed = -180f;
        public void UpdateCircularRotationalAnim()
        {
            if (m_CircularAnimList.Count > 0)
            {
                var firstItem = m_CircularAnimList[0];

                Vector3 eulerAngles = firstItem.eulerAngles;

                eulerAngles += new Vector3(0f, 0f, 1f) * m_CircularAnimRotationalSpeed * Time.deltaTime;

                if (eulerAngles.z > 360f)
                {
                    eulerAngles.z -= 360f;
                }
                else if (eulerAngles.z < -360f)
                {
                    eulerAngles.z += 360f;
                }

                foreach (var item in m_CircularAnimList)
                {
                    item.eulerAngles = eulerAngles;
                }
            }
        }

        private bool m_IsShowCircularRotationalAnim = false;
        public void ShowCircularRotationalAnim(EventPinballShowCircularRotationalAnim data)
        {
            foreach (var item in m_CircularProgressList)
            {
                item.gameObject.SetActive(false);
            }

            foreach (var item in m_CircularAnimList)
            {
                item.gameObject.SetActive(true);
                item.eulerAngles = Vector3.zero;
            }
            m_IsShowCircularRotationalAnim = true;
        }
        public void HideCircularRotationalAnim(EventPinballHideCircularRotationalAnim data)
        {
            m_IsShowCircularRotationalAnim = false;

            foreach (var item in m_CircularProgressList)
            {
                item.gameObject.SetActive(true);
            }

            foreach (var item in m_CircularAnimList)
            {
                item.gameObject.SetActive(false);
            }
        }
        #endregion

        #region 事件
        public void InitEvent()
        {
            FishingPinballAct.Subscribe<EventPinballEnergyArrowData>(UpdateEnergyArrowList);
            FishingPinballAct.Subscribe<EventPinballEnergyArrowRestoreData>(RestoreEnergyArrowList);
            FishingPinballAct.Subscribe<EventPinballUpdateBonusCircularProgress>(UpdateBonusCircularProgress);
            FishingPinballAct.Subscribe<EventPinballPlayArrowBreathAnimData>(PlayArrowBreathAnim);
            FishingPinballAct.Subscribe<EventPinballStopArrowBreathAnimData>(HideArrowGameObjectList);
            FishingPinballAct.Subscribe<EventPinballPlayLightOnAnimData>(PlayLightOnAnim);
            FishingPinballAct.Subscribe<EventPinballShowFiringPinData>(ShowFiringPin);
            FishingPinballAct.Subscribe<EventPinballHideFiringPinData>(HideFiringPin);
            FishingPinballAct.Subscribe<EventPinballShowCircularRotationalAnim>(ShowCircularRotationalAnim);
            FishingPinballAct.Subscribe<EventPinballHideCircularRotationalAnim>(HideCircularRotationalAnim);
        }
        #endregion

        #region 生命周期
        // Start is called before the first frame update
        void Start()
        {
            m_DataManager = GContext.container.Resolve<EventPinballDataManager>();
            m_DataManager.BonusResponseNumber = m_ResponseNumber;

            InitEvent();
        }

        // Update is called once per frame
        void Update()
        {
            if (Input.GetKeyUp(KeyCode.Escape))
            {
                // 关闭当前Act
                GContext.Publish(new UnloadActToNextAct());
            }

            if (m_IsShowCircularRotationalAnim)
            {
                UpdateCircularRotationalAnim();
            }
        }
        #endregion
    }
}