//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Saturday, September 02, 2017
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using UnityEngine.Events;

namespace vnxbqy.UI
{

    public class SkillButtonInterface : MonoBehaviour, IPointerDownHandler, IPointerUpHandler
    {

        public virtual void OnPointerDown(PointerEventData eventData)
        {
        }

        public virtual void OnPointerUp(PointerEventData eventData)
        {
        }

    }

    public class SkillButton : SkillButtonInterface, IPointerExitHandler
    {
        [SerializeField] int m_Index;
        [SerializeField] SkillTurnplate m_SkillTurnplate;
        [SerializeField] ImageEx m_Icon;
        [SerializeField] Transform m_Locked;
        [SerializeField] Text m_CoolDown;
        [SerializeField] Image m_CoolDownMask;
        [SerializeField] ScaleTween m_ScaleTween;
        [SerializeField] Image m_Selected;
        [SerializeField] LongPressShowPanel m_SkillTip;
        [SerializeField] UIEffect m_YinjiEffect;

        public Image icon { get { return m_Icon; } }
        public Transform locked { get { return m_Locked; } }

        UIEvent skillEvent1 = new UIEvent();
        UIEvent skillEvent2 = new UIEvent();

        bool isExit = false;

        bool inCountDown = false;
        float timer = 0f;
        int skillId = 0;

        public void Initialize(int skillId)
        {
            this.skillId = skillId;

            if (this.skillId == 0)
            {
                locked.SetActive(true);
                m_Icon.SetActive(false);
            }
            else
            {
                if (PreFightMission.Instance.IsFinished()
                 || PreFightMission.Instance.s_MissionDict.ContainsKey(1002))
                {
                    locked.SetActive(false);
                    m_Icon.SetActive(true);
                }

                var skillConfig = SkillConfig.Get(this.skillId);
                m_Icon.SetSprite(skillConfig.IconName);
            }

            m_CoolDown.SetActive(false);
            m_CoolDownMask.SetActive(false);
            m_Selected.SetActive(false);
            DisplaySkillDynamicInfo(true);
            HideSkillTip();
            PlayerDatas.Instance.playerDataRefreshEvent -= OnPlayerDataRefresh;
            if (GeneralDefine.skillYinjis.ContainsKey(this.skillId))
            {
                PlayerDatas.Instance.playerDataRefreshEvent += OnPlayerDataRefresh;
            }

            this.enabled = true;
        }

        public void Dispose()
        {
            if (showSkillTipClock != null)
            {
                Clock.Stop(showSkillTipClock);
                showSkillTipClock = null;
            }

            if (m_Index != 0)
            {
                HideSkillTip();
            }

            PlayerDatas.Instance.playerDataRefreshEvent -= OnPlayerDataRefresh;
            this.enabled = false;
        }

        public void AddDownListener(UnityAction _action)
        {
            skillEvent1.AddListener(_action);
        }

        public void AddUpListener(UnityAction _action)
        {
            skillEvent2.AddListener(_action);
        }

        public void RemoveAllListeners()
        {
            skillEvent1.RemoveAllListeners();
            skillEvent2.RemoveAllListeners();
        }

        private void LateUpdate()
        {
            DisplaySkillDynamicInfo(false);

            if (inCountDown)
            {
                if (!m_CoolDown.gameObject.activeSelf)
                {
                    m_CoolDown.SetActive(true);
                }

                if (m_CoolDownMask != null && !m_CoolDownMask.gameObject.activeSelf)
                {
                    m_CoolDownMask.SetActive(true);
                }

                if (m_CoolDownMask != null)
                {
                    m_CoolDownMask.fillAmount = MainWinSkillController.Instance.GetSkillCD(m_Index).value.GetCountDownFillAmount();
                }

                timer -= Time.deltaTime;
                if (timer < 0f)
                {
                    var countDown = MainWinSkillController.Instance.GetSkillCD(m_Index).value.GetCountDown();

                    if (countDown > 1)
                    {
                        m_CoolDown.text = countDown.ToString("f0");
                    }
                    else
                    {
                        m_CoolDown.text = "";
                    }

                    timer += 1f;
                }

                inCountDown = MainWinSkillController.Instance.GetSkillCD(m_Index).value.IsCountDown();
                if (!inCountDown)
                {
                    PlayYinjiEffect();
                }
            }
            else
            {
                if (m_CoolDown.gameObject.activeSelf)
                {
                    m_CoolDown.SetActive(false);
                }

                if (m_CoolDownMask != null)
                {
                    if (m_CoolDownMask.gameObject.activeSelf)
                    {
                        m_CoolDownMask.SetActive(false);
                    }
                }

            }

        }

        public override void OnPointerDown(PointerEventData eventData)
        {
            base.OnPointerDown(eventData);
            ProcessForbid();
            PassEvent(eventData, ExecuteEvents.pointerDownHandler);

            if (this.skillId == 0)
            {
                return;
            }

            if (m_ScaleTween != null)
            {
                m_ScaleTween.Play();
            }

            m_Selected.SetActive(true);

            skillEvent1.Invoke();

            if (m_Index != 0)
            {
                if (showSkillTipClock != null)
                {
                    Clock.Stop(showSkillTipClock);
                }

                showSkillTipClock = Clock.AlarmAfter(1, ShowSkillTip);
            }

            isExit = false;
        }

        public override void OnPointerUp(PointerEventData eventData)
        {
            base.OnPointerUp(eventData);

            PassEvent(eventData, ExecuteEvents.pointerUpHandler);

            if (this.skillId == 0)
            {
                return;
            }

            if (m_ScaleTween != null)
            {
                m_ScaleTween.Play(true);
            }

            m_Selected.SetActive(false);

            if (isExit == false)
            {
                skillEvent2.Invoke();
            }

            if (showSkillTipClock != null)
            {
                Clock.Stop(showSkillTipClock);
                showSkillTipClock = null;
            }

            if (m_Index != 0)
            {
                HideSkillTip();
            }
        }

        public void OnPointerExit(PointerEventData eventData)
        {
            isExit = true;
        }

        public void PassEvent<T>(PointerEventData data, ExecuteEvents.EventFunction<T> function) where T : IEventSystemHandler
        {
            List<RaycastResult> results = new List<RaycastResult>();
            EventSystem.current.RaycastAll(data, results);
            GameObject current = data.pointerCurrentRaycast.gameObject;
            if (current != null && current == m_SkillTurnplate.gameObject)
            {
                ExecuteEvents.Execute(current, data, function);
            }
            else
            {
                for (int i = 0; i < results.Count; i++)
                {
                    if (current != results[i].gameObject)
                    {
                        if (ExecuteEvents.Execute(results[i].gameObject, data, function))
                        {
                            break;
                        }
                    }
                }
            }

        }

        private void Awake()
        {
            Skill.OnSkillCDFinished += OnSkillPrepared;
            Skill.OnSkillCast += OnSkillCast;
        }

        private void OnDestroy()
        {
            Skill.OnSkillCDFinished -= OnSkillPrepared;
            Skill.OnSkillCast -= OnSkillCast;
        }

        private void OnSkillPrepared(int skillId)
        {
            if (!this.enabled)
            {
                return;
            }

            if (this.skillId != skillId)
            {
                return;
            }

            EffectMgr.Instance.PlayUIEffect(1024, 1500, this.transform, false);
        }

        private void OnSkillCast(uint playerInstanceId, int skillId)
        {
            if (!this.enabled)
            {
                return;
            }

            if (playerInstanceId != PlayerDatas.Instance.PlayerId)
            {
                return;
            }

            if (this.skillId != skillId)
            {
                return;
            }

            EffectMgr.Instance.PlayUIEffect(1023, 1500, this.transform, false);
        }

        private void ProcessForbid()
        {
            var isUnLocked = this.skillId != 0;
            if (!isUnLocked)
            {
                switch (m_Index)
                {
                    case 1:
                        SysNotifyMgr.Instance.ShowTip("Skill1Btn_Unlock");
                        break;
                    case 2:
                        SysNotifyMgr.Instance.ShowTip("Skill2Btn_Unlock");
                        break;
                    case 3:
                        SysNotifyMgr.Instance.ShowTip("Skill3Btn_Unlock");
                        break;
                    case 4:
                        SysNotifyMgr.Instance.ShowTip("Skill4Btn_Unlock");
                        break;
                    case 5:
                        SysNotifyMgr.Instance.ShowTip("Skill5Btn_Unlock");
                        break;
                    case 6:
                        SysNotifyMgr.Instance.ShowTip("Skill6Btn_Unlock");
                        break;
                    case 7:
                        SysNotifyMgr.Instance.ShowTip("Skill7Btn_Unlock");
                        break;
                    case 8:
                        SysNotifyMgr.Instance.ShowTip("SkillXpBtn_Unlock");
                        break;
                }

                return;
            }

            if (PlayerDatas.Instance.hero == null)
            {
                return;
            }

            var skill = PlayerDatas.Instance.hero.SkillMgr.Get(this.skillId);
            if (!skill.IsValid())
            {
                SysNotifyMgr.Instance.ShowTip("SkillBtn_CD");
                return;
            }
        }

        Clock showSkillTipClock;
        private void ShowSkillTip()
        {
            if (this.skillId == 0)
            {
                return;
            }

            if (m_SkillTip)
            {
                m_SkillTip.SetActive(true);
                m_SkillTip.Display(this.skillId);
            }
        }

        private void HideSkillTip()
        {
            if (m_SkillTip)
            {
                m_SkillTip.SetActive(false);
            }
        }

        private void DisplaySkillDynamicInfo(bool force)
        {
            var skillCd = MainWinSkillController.Instance.GetSkillCD(m_Index);
            if (force || skillCd.dirty)
            {
                var data = skillCd.Fetch();
                inCountDown = data.IsCountDown();

                var countDown = MainWinSkillController.Instance.GetSkillCD(m_Index).value.GetCountDown();
                if (countDown > 0)
                {
                    m_CoolDown.text = countDown.ToString("f0");
                }
                else
                {
                    m_CoolDown.text = "";
                }

                PlayYinjiEffect();
            }

            var skillForbid = MainWinSkillController.Instance.GetSkillForbid(m_Index);
            if (force || skillForbid.dirty)
            {
                m_Icon.gray = skillForbid.Fetch();
            }
        }

        private void OnPlayerDataRefresh(PlayerDataType type)
        {
            switch (type)
            {
                case PlayerDataType.CDBPlayerRefresh_YinjiCount:
                    PlayYinjiEffect();
                    break;
            }
        }

        YinJiModel yinjiModel { get { return ModelCenter.Instance.GetModel<YinJiModel>(); } }
        private void PlayYinjiEffect()
        {
            if (m_YinjiEffect == null)
            {
                return;
            }

            var skillCd = MainWinSkillController.Instance.GetSkillCD(m_Index);
            var playYinjiEffect = yinjiModel.IsSkillYinjiEnough(this.skillId) && !skillCd.value.IsExclusiveCountDown();
            if (playYinjiEffect)
            {
                if (!m_YinjiEffect.IsPlaying)
                {
                    m_YinjiEffect.Play();
                }
            }
            else
            {
                if (m_YinjiEffect.IsPlaying)
                {
                    m_YinjiEffect.Stop();
                }
            }
        }


    }

}