//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Tuesday, July 31, 2018
//--------------------------------------------------------

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

using UnityEngine;
using UnityEngine.UI;

namespace vnxbqy.UI {

    public class TalentWin : Window
    {
        [SerializeField] TalentSeriesBehaviour[] m_TalentSeries;
        [SerializeField] TalentTreeScriptable[] m_TalentConfigs;
        [SerializeField] RectTransform m_ContainerSelect;
        [SerializeField] Button m_TalentTypeSelect;
        [SerializeField] Text m_TalentType;
        [SerializeField] Text m_TalentTitle;

        [SerializeField] float m_AutoSelectOffset = 62f;
        [SerializeField] ScrollRect m_Scroller;
        [SerializeField] List<TalentSkillBehaviour> m_TalentSkills;
        [SerializeField] List<Image> m_Arrows;

        [SerializeField] RectTransform m_ContainerSelectSkill;
        [SerializeField] Image m_SelectSkillIcon;
        [SerializeField] Text m_SelectSkillLevel;
        [SerializeField] Text m_SelectSkillName;

        [SerializeField] RectTransform m_ContainerUnActive;
        [SerializeField] RectTransform m_ContainerActive;
        [SerializeField] RectTransform m_ContainerBetter;
        [SerializeField] RectTransform m_ContainerMax;

        [SerializeField] Text[] m_SelectConditions;
        [SerializeField] Text m_SelectSkillEffect;
        [SerializeField] Text m_SelectNextEffect;


        [SerializeField] Button m_ResetPoint;
        [SerializeField] Button m_AddPoint;
        [SerializeField] Text m_AddPointBtnText;
        [SerializeField] Text m_SurplusPoint;

#if UNITY_EDITOR
        [SerializeField] TalentTreeScriptable m_EditorScriptable;
        [SerializeField] bool m_EditorMode;
        [SerializeField] string m_StraightArrowName;
        [SerializeField] string m_TurnArrowName;
#endif

        TalentModel model { get { return ModelCenter.Instance.GetModel<TalentModel>(); } }
        PackModel pack { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        #region Built-in
        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
            m_TalentTypeSelect.onClick.AddListener(SelectTalentType);
            m_ResetPoint.onClick.AddListener(ResetPoint);
            m_AddPoint.onClick.AddListener(AddPoint);
        }

        protected override void OnPreOpen()
        {
            model.selectSeries = 1;
            model.selectTalentType = model.GetTalentType(0);
            Display();
            model.selectTalentTypeEvnet += OnSelectTalentTypeEvnet;
            model.selectSeriesEvent += OnSelectSeriesEvent;
            model.selectSkillEvent += OnSelectSkillEvent;
            model.talentSkillUpdate += TalentSkillUpdate;
            model.talentPointUpdate += TalentPointUpdate;
            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshInfoEvent;
            PlayerSkillDatas.OnRefreshSkill += OnRefreshSkill;
        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {
            model.selectTalentTypeEvnet -= OnSelectTalentTypeEvnet;
            model.selectSeriesEvent -= OnSelectSeriesEvent;
            model.selectSkillEvent -= OnSelectSkillEvent;
            model.talentSkillUpdate -= TalentSkillUpdate;
            model.talentPointUpdate -= TalentPointUpdate;
            PlayerSkillDatas.OnRefreshSkill -= OnRefreshSkill;
            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshInfoEvent;
            for (int i = 0; i < m_TalentSeries.Length; i++)
            {
                m_TalentSeries[i].Dispose();
            }
            for (int i = 0; i < m_TalentSkills.Count; i++)
            {
                m_TalentSkills[i].Dispose();
            }

#if UNITY_EDITOR
            if (m_EditorScriptable != null)
            {
                m_EditorScriptable = null;
            }
#endif
        }

        protected override void OnAfterClose()
        {
        }
        #endregion

        protected override void LateUpdate()
        {
            base.LateUpdate();
#if UNITY_EDITOR
            if (m_EditorMode && m_EditorScriptable != null)
            {
                DisplayTalentLayout(m_EditorScriptable);
            }
#endif
        }

        void Display()
        {
            for (int i = 0; i < m_TalentSeries.Length; i++)
            {
                m_TalentSeries[i].Display();
            }

            DisplaySkills();
            DisplayTalentType();
            DisplaySelectSkill();
            DisplayTalentPoint();
            DisplayLevelUp();
        }

        void DisplaySkills()
        {
            var job = PlayerDatas.Instance.baseData.Job;
            List<int> talents = null;
            model.TryGetTalents(job, model.selectTalentType, model.selectSeries, out talents);

            TalentTreeScriptable selectScriptable = null;
            for (int i = 0; i < m_TalentConfigs.Length; i++)
            {
                if (m_TalentConfigs[i].Belong(job, model.selectTalentType, model.selectSeries))
                {
                    selectScriptable = m_TalentConfigs[i];
                    DisplayTalentLayout(selectScriptable);
                    break;
                }
            }

            List<int> sortTalents = new List<int>(talents);
            sortTalents.Sort(Compare);

            var index = 0;
            if (sortTalents != null && sortTalents.Count > 0)
            {
                index = 0;
            }
            model.selectSkill = sortTalents[index];
            if (selectScriptable != null)
            {
                var rect = m_Scroller.transform as RectTransform;
                var skillRect = m_TalentSkills[0].transform as RectTransform;
                m_Scroller.verticalNormalizedPosition = selectScriptable.GetPercentBySkillElement(index, rect.sizeDelta.y, m_AutoSelectOffset);
            }
            for (int i = 0; i < m_TalentSkills.Count; i++)
            {
                if (sortTalents != null && i < sortTalents.Count)
                {
                    m_TalentSkills[i].SetActive(true);
                    m_TalentSkills[i].Display(sortTalents[i]);
                }
                else
                {
                    m_TalentSkills[i].Dispose();
                    m_TalentSkills[i].SetActive(false);
                }
            }

            var talentTypeDisplay = Language.Get(StringUtility.Contact("TalentType_", model.selectTalentType));
            var seriesDisplay = Language.Get(StringUtility.Contact("TalentSeries_", model.selectSeries));
            m_TalentTitle.text = StringUtility.Contact(talentTypeDisplay, "·", seriesDisplay);
        }

        void DisplayTalentType()
        {
            m_ContainerSelect.SetActive(model.talentTypeCount > 1);
            if (model.talentTypeCount > 1)
            {
                var unselectTalentType = model.selectTalentType == model.GetTalentType(0) ? model.GetTalentType(1) : model.GetTalentType(0);
                var point = model.GetTalentTypePoint(unselectTalentType);
                var job = PlayerDatas.Instance.baseData.Job;
                var talentTypeDisplay = Language.Get(StringUtility.Contact("TalentBtnType_", unselectTalentType));
                m_TalentType.text = StringUtility.Contact(talentTypeDisplay, "（", point, "）");
            }
        }

        void DisplaySelectSkill()
        {
            DisplaySkillInfo();
            DisplayConditions();
            DisplaySkillEffect();
        }

        private void PlayerDataRefreshInfoEvent(PlayerDataType refreshType)
        {
            switch (refreshType)
            {
                case PlayerDataType.STR:
                case PlayerDataType.PNE:
                case PlayerDataType.PHY:
                case PlayerDataType.CON:
                    DisplayConditions();
                    break;
            }
        }

        private void OnRefreshSkill()
        {
            DisplayConditions();
        }

        void DisplayConditions()
        {
            TalentSkill talent;
            var index = 0;
            if (model.TryGetTalent(model.selectSkill, out talent))
            {
                var talentConfig = talent.GetTalentConfig(talent.level + 1);
                var skillConfig = talent.GetSkillConfig(talent.level + 1);
                if (talentConfig != null)
                {
                    var requireSeriesPoint = skillConfig.RequireTalentSeriesPoint();
                    if (requireSeriesPoint != 0 && index < m_SelectConditions.Length)
                    {
                        m_SelectConditions[index].SetActive(true);
                        var requireSeries = skillConfig.RequireTalentSeries();
                        var point = model.GetSeriesPoint(talentConfig.type, requireSeries);
                        var requireDisplay = StringUtility.Contact(point, "/", requireSeriesPoint);
                        requireDisplay = UIHelper.AppendColor(point >= requireSeriesPoint ?
                            TextColType.Green : TextColType.Red, requireDisplay);
                        var seriesDisplay = Language.Get("TalentSeriesCondition", Language.Get(StringUtility.Contact("TalentSeries_", requireSeries)));
                        m_SelectConditions[index].text = StringUtility.Contact(seriesDisplay, requireDisplay);
                        index++;
                    }
                    var requireProperty = skillConfig.RequireProperty();
                    if (requireProperty != 0 && index < m_SelectConditions.Length)
                    {
                        m_SelectConditions[index].SetActive(true);
                        var requirePropertyValue = skillConfig.RequirePropertyValue();
                        var propertyValue = (int)UIHelper.GetPropertyValue((PropertyType)requireProperty);
                        var requireDisplay = StringUtility.Contact(propertyValue, "/", requirePropertyValue);
                        requireDisplay = UIHelper.AppendColor(propertyValue >= requirePropertyValue ?
                            TextColType.Green : TextColType.Red, requireDisplay);
                        var propertyConfig = PlayerPropertyConfig.Get(requireProperty);
                        var propertyDisplay = Language.Get("TalentPropertyCondition", propertyConfig.Name);
                        m_SelectConditions[index].text = StringUtility.Contact(propertyDisplay, requireDisplay);
                        index++;
                    }
                }
                if (skillConfig != null && index < m_SelectConditions.Length)
                {
                    var learnSkillConfig = SkillConfig.Get(skillConfig.LearnSkillReq);
                    if (skillConfig.LearnSkillReq != 0)
                    {
                        if (learnSkillConfig.FuncType == 1)
                        {
                            m_SelectConditions[index].SetActive(true);
                            var treasureModel = ModelCenter.Instance.GetModel<TreasureModel>();
                            var treasureId = treasureModel.GetTreasureBySkillId(skillConfig.LearnSkillReq);
                            var treasureConfig = TreasureConfig.Get(treasureId);
                            bool satisfy = PlayerDatas.Instance.skill.GetSKillById(skillConfig.LearnSkillReq) != null;
                            var requireDisplay = StringUtility.Contact(learnSkillConfig.SkillName, "（", treasureConfig.Name, "）");
                            requireDisplay = UIHelper.AppendColor(satisfy ? TextColType.Green : TextColType.Red, requireDisplay);
                            m_SelectConditions[index].text = StringUtility.Contact(Language.Get("TalentPreTreasureSkillCondition"), requireDisplay);
                            index++;
                        }
                        else
                        {
                            TalentSkill learnTalent;
                            if (model.TryGetTalent(skillConfig.LearnSkillReq, out learnTalent))
                            {
                                m_SelectConditions[index].SetActive(true);
                                var requireDisplay = StringUtility.Contact(learnSkillConfig.SkillName, " ", learnTalent.level, "/", skillConfig.LearnSkillLV);
                                requireDisplay = UIHelper.AppendColor(learnTalent.level >= skillConfig.LearnSkillLV ?
                                    TextColType.Green : TextColType.Red, requireDisplay);
                                m_SelectConditions[index].text = StringUtility.Contact(Language.Get("TalentPreSkillCondition"), requireDisplay);
                                index++;
                            }
                        }
                    }
                }
            }
            for (int i = index; i < m_SelectConditions.Length; i++)
            {
                m_SelectConditions[i].SetActive(false);
            }
        }

        void DisplaySkillInfo()
        {
            TalentSkill talent;
            m_ContainerSelectSkill.SetActive(false);
            if (model.TryGetTalent(model.selectSkill, out talent))
            {
                m_ContainerSelectSkill.SetActive(true);
                var config = talent.GetSkillConfig(talent.level);
                m_SelectSkillIcon.SetSprite(config.IconName);
                m_SelectSkillLevel.text = StringUtility.Contact(Language.Get("TalentLevel"), talent.level, "/", talent.maxLevel);
                m_SelectSkillName.text = config.SkillName;
                m_SelectSkillLevel.color = UIHelper.GetUIColor(talent.level >= talent.maxLevel ? TextColType.Green : TextColType.NavyBrown, true);
            }
        }

        void DisplaySkillEffect()
        {
            TalentSkill talent;
            if (model.TryGetTalent(model.selectSkill, out talent))
            {
                m_ContainerUnActive.SetActive(talent.level == 0);
                m_ContainerActive.SetActive(talent.level > 0);
                m_ContainerBetter.SetActive(talent.level < talent.maxLevel);
                m_ContainerMax.SetActive(talent.level >= talent.maxLevel);

                if (talent.level > 0)
                {
                    var config = talent.GetSkillConfig(talent.level);
                    m_SelectSkillEffect.text = config.Description;
                }
                if (talent.level < talent.maxLevel)
                {
                    var nextConfig = talent.GetSkillConfig(talent.level + 1);
                    m_SelectNextEffect.text = nextConfig.Description;
                }
            }
        }

        bool TryGetTalentConfig(out TalentTreeScriptable config)
        {
            config = null;
            for (int i = 0; i < m_TalentConfigs.Length; i++)
            {
                if (m_TalentConfigs[i].Belong(PlayerDatas.Instance.baseData.Job, model.selectTalentType, model.selectSeries))
                {
                    config = m_TalentConfigs[i];
                    return true;
                }
            }
            return false;
        }

        void DisplayTalentPoint()
        {
            m_SurplusPoint.text = model.talentPoint.ToString();
        }

        private void TalentSkillUpdate(int _skillId)
        {
            if (_skillId == model.selectSkill)
            {
                DisplaySkillInfo();
                DisplayConditions();
                DisplaySkillEffect();
                DisplayLevelUp();
            }
        }

        private void TalentPointUpdate()
        {
            DisplayTalentPoint();
        }

        private void OnSelectTalentTypeEvnet()
        {
            model.selectSeries = 1;
            DisplaySkills();
            DisplaySelectSkill();
            DisplayTalentType();
        }

        private void OnSelectSeriesEvent()
        {
            DisplaySkills();
            DisplaySelectSkill();
        }

        private void OnSelectSkillEvent()
        {
            DisplaySelectSkill();
            DisplayLevelUp();
        }

        private void SelectTalentType()
        {
            if (model.talentTypeCount > 1)
            {
                model.selectTalentType = model.selectTalentType == model.GetTalentType(0) ?
                         model.GetTalentType(1) : model.GetTalentType(0);
            }
        }

        private void DisplayLevelUp()
        {
            TalentSkill talent;
            if (model.TryGetTalent(model.selectSkill, out talent))
            {
                m_AddPointBtnText.text = talent.level >= talent.maxLevel ? Language.Get("TalentHighestLevel") : Language.Get("TalentLevelUp");
            }
        }

        private void AddPoint()
        {
            TalentSkill talent;
            if (model.TryGetTalent(model.selectSkill, out talent))
            {
                int error;
                if (!model.SatisfyLevelUp(model.selectSkill, out error))
                {
                    model.ProcessLevelUpError(model.selectSkill, error);
                    return;
                }
                else
                {
                    C0304_tagCAddSkillPoint pak = new C0304_tagCAddSkillPoint();
                    pak.SkillID = (ushort)model.selectSkill;
                    GameNetSystem.Instance.SendInfo(pak);
                }
            }
        }

        private void ResetPoint()
        {
            if (model.GetAllTalentPoint() <= 0)
            {
                SysNotifyMgr.Instance.ShowTip("NoNeedResetTalentPoint");
                return;
            }
            var count = pack.GetItemCountByID(PackType.Item, model.talentResetBook);
            var config = ItemConfig.Get(model.talentResetBook);
            if (count > 0)
            {
                ConfirmCancel.ShowItemConfirm(Language.Get("TalentResetRequire", config.ItemName), model.talentResetBook, 1, () =>
                    {
                        CA550_tagCMResetMasterSkill pak = new CA550_tagCMResetMasterSkill();
                        GameNetSystem.Instance.SendInfo(pak);
                    });
            }
            else
            {
                ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("LackTalentBook",
                    config.ItemName, model.talentResetBookCost), (bool isOk) =>
                    {
                        if (isOk)
                        {
                            if (UIHelper.GetMoneyCnt(1) < (ulong)model.talentResetBookCost)
                            {
                                WindowCenter.Instance.Open<RechargeTipWin>();
                            }
                            else
                            {
                                CA550_tagCMResetMasterSkill pak = new CA550_tagCMResetMasterSkill();
                                GameNetSystem.Instance.SendInfo(pak);
                            }
                        }
                    });
            }
        }

        void DisplayTalentLayout(TalentTreeScriptable config)
        {
            m_Scroller.content.sizeDelta = config.contentSizeDelta;
            for (int i = 0; i < config.skillCount; i++)
            {
                var element = config.GetTalentElement(i);
                if (i < m_TalentSkills.Count)
                {
                    m_TalentSkills[i].transform.localPosition = element.position;
                }
            }
            var index = 0;
            for (int i = 0; i < config.arrowCount; i++)
            {
                var element = config.GetArrowElement(i);
                if (i < m_Arrows.Count)
                {
                    var arrow = m_Arrows[i];
                    arrow.SetActive(true);
                    arrow.transform.localPosition = element.position;
                    arrow.transform.localEulerAngles = element.rotation;
                    arrow.rectTransform.sizeDelta = element.sizeDelta;
                    arrow.SetSprite(element.iconKey);
                    index++;
                }
            }
            for (int i = index; i < m_Arrows.Count; i++)
            {
                m_Arrows[i].SetActive(false);
            }
        }

        int Compare(int x, int y)
        {
            var configx = TalentConfig.Get(x);
            var configy = TalentConfig.Get(y);
            if (configx != null && configy != null)
            {
                return configx.order.CompareTo(configy.order);
            }
            return 0;
        }

#if UNITY_EDITOR
        [ContextMenu("应用位置数据")]
        void ApplyPositionToScriptable()
        {
            if (m_EditorScriptable == null)
            {
                return;
            }
            var count = 0;
            for (int i = 0; i < m_TalentSkills.Count; i++)
            {
                if (m_TalentSkills[i].gameObject.activeSelf)
                {
                    m_EditorScriptable.ApplyTalentElement(count, m_TalentSkills[i].transform.localPosition);
                    count++;
                }
            }
            m_EditorScriptable.SyncTalentElementsCount(count);
            count = 0;
            if (m_Arrows != null)
            {
                for (int i = 0; i < m_Arrows.Count; i++)
                {
                    if (m_Arrows[i].gameObject.activeSelf)
                    {
                        m_EditorScriptable.ApplyArrowElement(count, m_Arrows[i].transform.localPosition,
                            m_Arrows[i].rectTransform.sizeDelta, m_Arrows[i].transform.localEulerAngles,
                            m_Arrows[i].sprite.name.Equals(m_StraightArrowName) ? "Talent_StraightArrow" : "Talent_TurnArrow");
                        count++;
                    }
                }
                m_EditorScriptable.SyncArrowElementsCount(count);
            }
        }
#endif
    }
}