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

using System;
using System.Collections;
using System.Collections.Generic;

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_SkillLevel;
        [SerializeField] Text m_SkillDescTxt;
        [SerializeField] Button m_LevelUp;
        [SerializeField] Text m_LevelUpLabel;
        [SerializeField] RedpointBehaviour m_LevelRedpoint;
        [SerializeField] Button m_LeftBtn;
        [SerializeField] Button m_RightBtn;
        [SerializeField] List<SkillCell> m_QuickSkills = new List<SkillCell>();
        [SerializeField] Image m_DragImg;
        [SerializeField] Image m_DragSkillImg;
        [SerializeField] List<RectTransform> m_QuickSkillRect = new List<RectTransform>();
        [SerializeField] Button m_AutoUseXp;
        [SerializeField] Image m_AutoXpCheck;
        [SerializeField] Button m_SkillMatch;
        private List<int> skillListAct = new List<int>();
        private bool onXpCoolDown = false;

        private bool m_IsAutoUseXp = false;

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

        TreasureSkillModel treasureSkillModel
        {
            get { return ModelCenter.Instance.GetModel<TreasureSkillModel>(); }
        }

        #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();
            //    }
            //});
            m_SkillMatch.AddListener(() =>
            {
                WindowCenter.Instance.Open("SkillMatchWin");
                if (model.skillMatchRedpointable)
                {
                    model.skillMatchRedpointable = false;
                }
            });
            for (int i = 0; i < m_QuickSkills.Count; i++)
            {
                int index = i;
                m_QuickSkills[i].skillData.m_SkillBtn.onClick.AddListener(() =>
                {
                    OnQuickSkillClick(index);
                });
            }


            m_LevelUp.AddListener(LevelUp);
        }

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

            Input.multiTouchEnabled = false;

            PlayerSkillDatas.OnQuickSkillRefresh += OnUpdateQuickSkill;
            PlayerSkillDatas.OnRefreshSkill += OnRefreshSkill;
            model.OnRefreshSltSkill += OnUpdateQuickSkill;
            model.OnRefreshSltSkill += UpdateSltSkill;
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
            treasureSkillModel.treasureSkillRefresh += TreasureSkillRefresh;
            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();
            DisplayButtonState();

            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.SetActive(false);
            PlayerSkillDatas.OnQuickSkillRefresh -= OnUpdateQuickSkill;
            PlayerSkillDatas.OnRefreshSkill -= OnRefreshSkill;
            model.OnRefreshSltSkill -= UpdateSltSkill;
            model.OnRefreshSltSkill -= OnUpdateQuickSkill;
            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
            treasureSkillModel.treasureSkillRefresh -= TreasureSkillRefresh;
            AchievementGoto.achievementType = 0;
            Input.multiTouchEnabled = true;
            treasureSkillModel.SetAlreadyRemind();
        }

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

        void UpdatePageBtn()
        {
            if (flipActScroll.Page == 0)
            {
                m_LeftBtn.SetActive(false);
            }
            else
            {
                m_LeftBtn.SetActive(true);
            }
            if (flipActScroll.Page == flipActScroll.pageCnt - 1)
            {
                m_RightBtn.SetActive(false);
            }
            else
            {
                m_RightBtn.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] == 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.SetActive(true);
                    skillTran.GetComponent<SkillCell>().Refresh(skillListAct[index]);
                }
                else
                {
                    skillTran.SetActive(false);
                }
            }
        }

        void OnUpdateSltSkillInfo()
        {
            SkillConfig cfg = SkillConfig.Get(model.presentSltSkillID);
            m_ContainerSkillDetails.SetActive(cfg != null);
            m_ContainerUnselect.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);

                TreasureSkill treasureSkill;
                var level = 0;
                if (treasureSkillModel.TryGetSkill(cfg.SkillTypeID, out treasureSkill))
                {
                    level = treasureSkill.level;
                    m_LevelRedpoint.redpointId = treasureSkill.levelUpRedpoint.id;

                    bool isMax = treasureSkill.level >= treasureSkill.maxLevel;
                    m_LevelUp.SetActive(!isMax && treasureSkill.level > 0);
                }
                if (level > 0)
                {
                    m_SkillLevel.text = Language.Get("SkillActLevel", level);
                }
                else
                {
                    m_SkillLevel.text = Language.Get("SkillActLevel", Language.Get("TreasureSkilllock"));
                }
            }
        }

        void GetSkillList()
        {
            RefreshSkills();
            if (skillListAct.Count < 1)
            {
                return;
            }
            model.presentSltSkillID = skillListAct[0];
            flipActScroll.pageCnt = Mathf.CeilToInt((float)skillListAct.Count / SkillModel.ACT_SKILL_NUM);
            UpdateSltSkill();
        }

        void RefreshSkills()
        {
            var _skillJobKey = (int)Math.Pow(2, PlayerDatas.Instance.baseData.Job);
            Dictionary<int, List<int>> dic = model.skillActDict[_skillJobKey];
            skillListAct.Clear();
            foreach (int key in dic.Keys)
            {
                List<int> typeList = dic[key];
                var skillId = typeList[0];
                foreach (var id in typeList)
                {
                    if (PlayerDatas.Instance.skill.GetSKillById(id) != null)
                    {
                        skillId = id;
                        break;
                    }
                }
                if (PlayerDatas.Instance.skill.GetFilterPlayerSkill(PlayerDatas.Instance.baseData.Job).Contains(skillId))
                {
                    continue;
                }
                skillListAct.Add(skillId);
            }
        }

        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 = SkillConfig.Get(intarray[i]);
                if (data != null)
                {
                    m_QuickSkills[i].skillData.SetSkillData(data.id);
                    m_QuickSkills[i].skillData.SetActive(true);
                    m_QuickSkills[i].skillData.m_LockImg.SetActive(false);
                }
                else
                {
                    m_QuickSkills[i].skillData.SetSkillData(skillCfg.SkillID);
                    m_QuickSkills[i].skillData.SetActive(false);
                    m_QuickSkills[i].skillData.m_LockImg.SetActive(true);
                    if (PlayerDatas.Instance.skill.GetSKillById(intarray[i]) != null)
                    {
                        m_QuickSkills[i].skillData.m_LockImg.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 = SkillConfig.Get(skillid);
                if (skillCfg != null)
                {
                    ServerTipDetails.DisplayNormalTip(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.SetActive(_select && _activeSkill);
            }
            //var _xpSkillId = model.GetXpSkillID();
            //bool xpSkillSelect = PlayerDatas.Instance.skill.GetSKillById(_xpSkillId) != null
            //                       && model.presentSltSkillID == _xpSkillId;

        }

        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.SetActive(!hasXpSkill);
        //    m_XpCoolDownImg.SetActive(false);
        //    onXpCoolDown = false;
        //    if (hasXpSkill)
        //    {
        //        Skill xpSkill = PlayerDatas.Instance.hero.SkillMgr.Get(xpSkillId);
        //        if (xpSkill.cd > 0)
        //        {
        //            m_XpCoolDownImg.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.SetActive(false);
        //        }
        //    }
        //    else
        //    {
        //        onXpCoolDown = false;
        //    }
        //}

        void DisplayButtonState()
        {
            m_LevelUp.SetColorful(m_LevelUpLabel, FuncOpen.Instance.IsFuncOpen(177));
        }


        private void OnFuncStateChangeEvent(int id)
        {
            if (id == 177)
            {
                DisplayButtonState();
            }
        }

        private void TreasureSkillRefresh(int skillId)
        {
            var config = SkillConfig.Get(model.presentSltSkillID);
            var skillTypeId = config.SkillTypeID;
            TreasureSkill treasureSkill;
            if (treasureSkillModel.TryGetSkill(skillTypeId, out treasureSkill))
            {
                model.presentSltSkillID = treasureSkill.GetSkillConfig(treasureSkill.level).SkillID;
            }
            RefreshSkills();
            //RefreshXpSkill();
            flipActScroll.RefreshActive();
            UpdateQuickSkillSelect();
            OnUpdateSltSkillInfo();
        }

        protected override void LateUpdate()
        {
            base.LateUpdate();
            if (model.skillDraging)
            {
                flipActScroll.locked = true;
                if (!m_DragImg.gameObject.activeSelf)
                {
                    m_DragImg.SetActive(true);
                    SkillConfig cfg = SkillConfig.Get(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.SetActive(false);
                    CheckReplaceQuickSkill();
                    flipActScroll.locked = false;
                }
            }
            //if (onXpCoolDown)
            //{
            //    RefreshXpCd();
            //}
        }

        private void LevelUp()
        {
            if (!FuncOpen.Instance.IsFuncOpen(177))
            {
                FuncOpen.Instance.ProcessorFuncErrorTip(177);
                return;
            }
            var config = SkillConfig.Get(model.presentSltSkillID);
            TreasureSkillLevelUpWin.skillId = config.SkillTypeID;
            WindowCenter.Instance.Open<TreasureSkillLevelUpWin>();
        }

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

        private void UpdateAutoXp()
        {
            m_AutoXpCheck.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 int m_AchieveSkillId = 0;
        void HandleAchievement()
        {
            m_AchieveSkillId = 0;
            if (AchievementGoto.achievementType == AchievementGoto.ExcuteSkill)
            {
                var _cfg = SuccessConfig.Get(AchievementGoto.guideAchievementId);
                var _skillId = SkillConfig.FindSkillByJob(_cfg.Condition, PlayerDatas.Instance.baseData.Job);
                if (_skillId != 0)
                {
                    m_AchieveSkillId = _skillId;
                    var _index = skillListAct.FindIndex((x) =>
                     {
                         return x == _skillId;
                     });
                    if (_index != -1)
                    {
                        var _page = _index / SkillModel.ACT_SKILL_NUM;
                        if (_page == 1)
                        {
                            flipActScroll.FlipRight();
                        }
                        flipActScroll.RefreshActive();
                        SysNotifyMgr.Instance.ShowTip("Achievement_109");
                    }
                }
            }
        }
    }

}