//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Friday, November 10, 2017
//--------------------------------------------------------

using System;
using System.Collections;
using System.Collections.Generic;
using TableConfig;
using UnityEngine;
using UnityEngine.UI;
namespace Snxxz.UI
{
    public class SkillAccordWin : Window
    {
        [SerializeField] FlipScroll flipActScroll;
        [SerializeField] RectTransform m_ContainerSkillDetails;
        [SerializeField] RectTransform m_ContainerUnselect;
        [SerializeField] Text m_TreasureNameTxt;
        [SerializeField] Text m_SkillNameTxt;
        [SerializeField] Text m_SkillCoolDownTxt;
        [SerializeField] Text m_SkillDescTxt;
        [SerializeField] Button m_LeftBtn;
        [SerializeField] Button m_RightBtn;
        [SerializeField] List<SkillCell> m_QuickSkills = new List<SkillCell>();
        [SerializeField] SkillCell m_XpSkill;
        [SerializeField] Image m_XpCoolDownImg;
        [SerializeField] Text m_XpCoolDownTxt;
        [SerializeField] Image m_DragImg;
        [SerializeField] Image m_DragSkillImg;
        [SerializeField] List<RectTransform> m_QuickSkillRect = new List<RectTransform>();
        [SerializeField] Button m_PageOneBtn;
        [SerializeField] Button m_PageTwoBtn;
        [SerializeField] SkillTurnplate m_SkillTurnplate;
        [SerializeField] Button m_AutoUseXp;
        [SerializeField] Image m_AutoXpCheck;
        private List<SkillConfig> skillListAct = new List<SkillConfig>();
        private bool onXpCoolDown = false;

        private bool m_IsAutoUseXp = false;

        SkillModel m_Model;
        SkillModel model
        {
            get
            {
                return m_Model ?? (m_Model = ModelCenter.Instance.GetModel<SkillModel>());
            }
        }

        #region Built-in
        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
            flipActScroll.OnRefreshData += OnRefreshActSkill;
            flipActScroll.OnTweenCompt += OnTweenCompt;
            m_LeftBtn.onClick.AddListener(flipActScroll.FlipLeft);
            m_RightBtn.onClick.AddListener(flipActScroll.FlipRight);
            m_AutoUseXp.onClick.AddListener(OnAutoUseXp);
            m_PageOneBtn.onClick.AddListener(() =>
            {
                if (m_SkillTurnplate.GroupIndex != 1)
                {
                    m_SkillTurnplate.Turn(GestureType.Left);
                    UpdateSkillPage();
                }
            });
            m_PageTwoBtn.onClick.AddListener(() =>
            {
                if (m_SkillTurnplate.GroupIndex != 2)
                {
                    m_SkillTurnplate.Turn(GestureType.Right);
                    UpdateSkillPage();
                }
            });
            for (int i = 0; i < m_QuickSkills.Count; i++)
            {
                int index = i;
                m_QuickSkills[i].skillData.m_SkillBtn.onClick.AddListener(() =>
                {
                    OnQuickSkillClick(index);
                });
            }

            m_XpSkill.skillData.m_SkillBtn.AddListener(() =>
            {
                OnXpClick();
            });
        }

        protected override void OnPreOpen()
        {
            model.presentSltSkillID = 0;
            flipActScroll.locked = false;
            m_DragImg.gameObject.SetActive(false);

            Input.multiTouchEnabled = false;

            PlayerSkillDatas.OnQuickSkillRefresh += OnUpdateQuickSkill;
            PlayerSkillDatas.OnRefreshSkill += OnRefreshSkill;
            model.OnRefreshSltSkill += OnUpdateQuickSkill;
            model.OnRefreshSltSkill += UpdateSltSkill;
            GetSkillList();
            OnUpdateQuickSkill();
            for (int i = 0; i < SkillModel.QUICK_SKILL_COUNT; i++)
            {
                if (PlayerDatas.Instance.skill.GetQuickSkillByPos(i) != null)
                {
                    OnQuickSkillClick(i);
                    break;
                }
            }
            m_SkillTurnplate.Init();
            UpdateSkillPage();
            RefreshXpSkill();

            m_IsAutoUseXp = model.AutoUseXp();
            UpdateAutoXp();
        }

        protected override void OnActived()
        {
            base.OnActived();
            UpdatePageBtn();
        }

        private void OnRefreshSkill()
        {
            UpdateSltSkill();
            RefreshXpSkill();
        }

        protected override void OnAfterOpen()
        {
            HandleAchievement();
        }

        protected override void OnPreClose()
        {
            model.skillDraging = false;
            m_DragImg.gameObject.SetActive(false);
            PlayerSkillDatas.OnQuickSkillRefresh -= OnUpdateQuickSkill;
            PlayerSkillDatas.OnRefreshSkill -= OnRefreshSkill;
            model.OnRefreshSltSkill -= UpdateSltSkill;
            model.OnRefreshSltSkill -= OnUpdateQuickSkill;
            AchievementGoto.achievementType = 0;
            Input.multiTouchEnabled = true;
        }

        protected override void OnAfterClose()
        {
            model.SetAutoUseXp(m_IsAutoUseXp);
        }
        #endregion
        private void OnTweenCompt()
        {
            UpdatePageBtn();
        }

        void UpdatePageBtn()
        {
            if (flipActScroll.Page == 0)
            {
                m_LeftBtn.gameObject.SetActive(false);
            }
            else
            {
                m_LeftBtn.gameObject.SetActive(true);
            }
            if (flipActScroll.Page == flipActScroll.pageCnt - 1)
            {
                m_RightBtn.gameObject.SetActive(false);
            }
            else
            {
                m_RightBtn.gameObject.SetActive(true);
            }
        }

        void OnRefreshActSkill(int page, RectTransform cell)
        {
            for (int i = 0; i < cell.childCount; i++)
            {
                Transform skillTran = cell.GetChild(i);
                int index = page * SkillModel.ACT_SKILL_NUM + i;
                if (index < skillListAct.Count)
                {
                    if(AchievementGoto.achievementType==AchievementGoto.ExcuteSkill
                        && skillListAct[index].SkillID == m_AchieveSkillId)
                    {
                        var _effect = AchievementGuideEffectPool.Require(3);
                        _effect.transform.SetParentEx(skillTran, Vector3.zero, Vector3.zero, Vector3.one);
                        (_effect.transform as RectTransform).anchoredPosition = Vector3.zero;
                        AchievementGoto.achievementType = 0;
                        m_AchieveSkillId = 0;
                    }
                    skillTran.gameObject.SetActive(true);
                    skillTran.GetComponent<SkillCell>().Refresh(skillListAct[index]);
                }
                else
                {
                    skillTran.gameObject.SetActive(false);
                }
            }
        }

        void OnUpdateSltSkillInfo()
        {
            SkillConfig cfg = Config.Instance.Get<SkillConfig>(model.presentSltSkillID);
            m_ContainerSkillDetails.gameObject.SetActive(cfg != null);
            m_ContainerUnselect.gameObject.SetActive(cfg == null);
            if (cfg != null)
            {
                m_SkillNameTxt.text = cfg.SkillName;
                m_TreasureNameTxt.text = cfg.Skillsource;
                m_SkillDescTxt.text = UIHelper.ReplaceNewLine(cfg.Description);
                m_SkillCoolDownTxt.text = cfg.CoolDownTime == 0 ? string.Empty : Language.Get("L1065", cfg.CoolDownTime / 1000);
            }
        }

        void GetSkillList()
        {
            var _skillJobKey = (int)Math.Pow(2, PlayerDatas.Instance.baseData.Job);
            if (!model.skillActDict.ContainsKey(_skillJobKey))
            {
                DebugEx.LogErrorFormat("不存在该职业的技能{0}", _skillJobKey);
                return;
            }
            Dictionary<int, List<SkillConfig>> dic = model.skillActDict[_skillJobKey];
            Dictionary<int, PlayerSkillData> playerskills = PlayerDatas.Instance.skill.GetAllSkill();
            skillListAct.Clear();
            foreach (int key in dic.Keys)
            {
                List<SkillConfig> typeList = dic[key];
                SkillConfig lvCfg = typeList[0];
                foreach (SkillConfig cfg in typeList)
                {
                    if (PlayerDatas.Instance.skill.GetSKillById(cfg.SkillID) != null)
                    {
                        lvCfg = cfg;
                        break;
                    }
                }
                if (PlayerDatas.Instance.skill.GetFilterPlayerSkill(PlayerDatas.Instance.baseData.Job).Contains(lvCfg.SkillID))
                {
                    continue;
                }
                skillListAct.Add(lvCfg);
            }
            if (skillListAct.Count < 1)
            {
                return;
            }
            model.presentSltSkillID = skillListAct[0].SkillID;
            flipActScroll.pageCnt = Mathf.CeilToInt((float)skillListAct.Count / SkillModel.ACT_SKILL_NUM);
            UpdateSltSkill();
        }

        void OnUpdateQuickSkill()
        {
            int[] intarray = model.GetQuickBaseSkillArray(PlayerDatas.Instance.baseData.Job);
            for (int i = 0; i < m_QuickSkills.Count; i++)
            {
                PlayerSkillData data = PlayerDatas.Instance.skill.GetQuickSkillByPos(i);
                SkillConfig skillCfg = Config.Instance.Get<SkillConfig>(intarray[i]);
                if (data != null)
                {
                    m_QuickSkills[i].skillData.SetSkillData(data.id);
                    m_QuickSkills[i].skillData.SetActive(true);
                    m_QuickSkills[i].skillData.m_LockImg.gameObject.SetActive(false);
                }
                else
                {
                    m_QuickSkills[i].skillData.SetSkillData(skillCfg.SkillID);
                    m_QuickSkills[i].skillData.SetActive(false);
                    m_QuickSkills[i].skillData.m_LockImg.gameObject.SetActive(true);
                    if (PlayerDatas.Instance.skill.GetSKillById(intarray[i]) != null)
                    {
                        m_QuickSkills[i].skillData.m_LockImg.gameObject.SetActive(false);
                    }
                }
            }
        }

        private void OnQuickSkillClick(int _index)
        {
            PlayerSkillData skill = PlayerDatas.Instance.skill.GetQuickSkillByPos(_index);
            if (skill == null)
            {
                int skillid = model.GetQuickBaseSkillArray(PlayerDatas.Instance.baseData.Job)[_index];
                SkillConfig skillCfg = Config.Instance.Get<SkillConfig>(skillid);
                if (skillCfg != null)
                {
                    MessageWin.Inst.ShowFixedTip(Language.Get("L1115", skillCfg.Skillsource));
                }
                return;
            }
            model.presentSltSkillID = skill.id;
            UpdateSltSkill();
        }

        private void OnXpClick()
        {
            var _xpSkillId = model.GetXpSkillID();
            if (PlayerDatas.Instance.skill.GetSKillById(_xpSkillId) != null)
            {
                model.presentSltSkillID = _xpSkillId;
                UpdateSltSkill();
            }
        }

        private void UpdateQuickSkillSelect()
        {
            for (int i = 0; i < m_QuickSkills.Count; i++)
            {
                var _skillData = m_QuickSkills[i].skillData;
                var _select = _skillData.skillId == model.presentSltSkillID;
                var _activeSkill = PlayerDatas.Instance.skill.GetSKillById(_skillData.skillId) != null;
                _skillData.m_SelectImg.gameObject.SetActive(_select && _activeSkill);
            }
            var _xpSkillId = model.GetXpSkillID();
            bool xpSkillSelect = PlayerDatas.Instance.skill.GetSKillById(_xpSkillId) != null
                                   && model.presentSltSkillID == _xpSkillId;
            m_XpSkill.skillData.m_SelectImg.gameObject.SetActive(xpSkillSelect);
        }

        private void UpdateSltSkill()
        {
            flipActScroll.RefreshActive();
            UpdateQuickSkillSelect();
            OnUpdateSltSkillInfo();
        }

        private void RefreshXpSkill()
        {
            var xpSkillId = model.GetXpSkillID();
            m_XpSkill.skillData.SetSkillData(xpSkillId);
            var hasXpSkill = PlayerDatas.Instance.skill.GetSKillById(xpSkillId) != null;
            m_XpSkill.skillData.SetActive(hasXpSkill);
            m_XpSkill.skillData.m_LockImg.gameObject.SetActive(!hasXpSkill);
            m_XpCoolDownImg.gameObject.SetActive(false);
            onXpCoolDown = false;
            if (hasXpSkill)
            {
                Skill xpSkill = PlayerDatas.Instance.hero.SkillMgr.Get(xpSkillId);
                if (xpSkill.cd > 0)
                {
                    m_XpCoolDownImg.gameObject.SetActive(true);
                    onXpCoolDown = true;
                    RefreshXpCd();
                }
            }
        }

        private void RefreshXpCd()
        {
            if (model.xpSkill != null)
            {
                m_XpCoolDownImg.fillAmount = model.xpSkill.cd / (model.xpSkill.skillInfo.config.CoolDownTime * Constants.F_GAMMA);
                m_XpCoolDownTxt.text = TimeUtility.SecondsToHMS((int)model.xpSkill.cd);
                if (model.xpSkill.cd <= 0)
                {
                    onXpCoolDown = false;
                    m_XpCoolDownImg.gameObject.SetActive(false);
                }
            }
            else
            {
                onXpCoolDown = false;
            }
        }

        protected override void LateUpdate()
        {
            base.LateUpdate();
            if (model.skillDraging)
            {
                flipActScroll.locked = true;
                if (!m_DragImg.gameObject.activeSelf)
                {
                    m_DragImg.gameObject.SetActive(true);
                    SkillConfig cfg = Config.Instance.Get<SkillConfig>(model.skillDragId);
                    if (cfg != null)
                    {
                        m_DragSkillImg.SetSprite(cfg.IconName);
                    }
                }
                Vector2 _pos;
                if (RectTransformUtility.ScreenPointToLocalPointInRectangle(this.transform as RectTransform,
                    Input.mousePosition, CameraManager.uiCamera, out _pos))
                {
                    m_DragImg.rectTransform.localPosition = _pos;
                }

                if (Input.GetMouseButtonUp(0))
                {
                    model.skillDraging = false;
                    m_DragImg.gameObject.SetActive(false);
                    CheckReplaceQuickSkill();
                    flipActScroll.locked = false;
                }
            }
            if (onXpCoolDown)
            {
                RefreshXpCd();
            }
        }

        private void OnAutoUseXp()
        {
            m_IsAutoUseXp = !m_IsAutoUseXp;
            UpdateAutoXp();
        }

        private void UpdateAutoXp()
        {
            m_AutoXpCheck.gameObject.SetActive(m_IsAutoUseXp);
        }

        private void UpdateSkillPage()
        {
            m_PageOneBtn.image.SetSprite(m_SkillTurnplate.GroupIndex == 1 ?
                "SkillRightbtn_A" : "Skillbtnbtn_A");
            m_PageTwoBtn.image.SetSprite(m_SkillTurnplate.GroupIndex == 2 ?
                "SkillRightbtn_A" : "Skillbtnbtn_A");
        }

        private void CheckReplaceQuickSkill()
        {
            for (int i = 0; i < m_QuickSkillRect.Count; i++)
            {
                if (!InDisplay(i))
                {
                    continue;
                }
                var des = RectTransformUtility.CalculateRelativeRectTransformBounds(this.transform, m_QuickSkillRect[i]);
                var src = RectTransformUtility.CalculateRelativeRectTransformBounds(this.transform, m_DragImg.rectTransform);
                var dis = Vector3.Distance(des.center, src.center);
                if (dis < m_QuickSkillRect[i].rect.width / 2)
                {
                    if (PlayerDatas.Instance.skill.GetQuickSkillByPos(i) != null)
                    {
                        if (m_QuickSkills[i].skillData.skillId == model.skillDragId)
                        {
                            //SoundPlayer.Instance.PlayUIAudio(2);
                            return;
                        }
                        PlayerDatas.Instance.skill.SetQuickSkill(i, model.skillDragId);
                        SoundPlayer.Instance.PlayUIAudio(28);
                        UpdateSltSkill();
                    }
                    //SoundPlayer.Instance.PlayUIAudio(2);
                    break;
                }
            }
        }

        private bool InDisplay(int _index)
        {
            if (m_SkillTurnplate.GroupIndex == 1)
            {
                return _index < 3;
            }
            else if (m_SkillTurnplate.GroupIndex == 2)
            {
                return _index > 2;
            }
            return true;
        }

        private int m_AchieveSkillId = 0;
        void HandleAchievement()
        {
            m_AchieveSkillId = 0;
            if (AchievementGoto.achievementType == AchievementGoto.ExcuteSkill)
            {
                var _cfg = Config.Instance.Get<SuccessConfig>(AchievementGoto.guideAchievementId);
                var _skillId = ModelCenter.Instance.GetModel<AchievementModel>().FindSkillByJob(_cfg.Condition, PlayerDatas.Instance.baseData.Job);
                if (_skillId != 0)
                {
                    m_AchieveSkillId = _skillId;
                    var _index = skillListAct.FindIndex((x) =>
                     {
                         return x.SkillID == _skillId;
                     });
                    if (_index != -1)
                    {
                        var _page = _index / SkillModel.ACT_SKILL_NUM;
                        if (_page == 1)
                        {
                            flipActScroll.FlipRight();
                        }
                        flipActScroll.RefreshActive();
                        SysNotifyMgr.Instance.ShowTip("Achievement_109");
                    }
                }
            }
        }
    }

}