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

using System;
using System.Collections;
using System.Collections.Generic;
using TableConfig;
using UnityEngine;
using UnityEngine.UI;

namespace Snxxz.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] ScrollRect m_Scroller;
        [SerializeField] TalentSkillBehaviour[] m_TalentSkills;
        [SerializeField] 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;
#endif

        TalentModel model { get { return ModelCenter.Instance.GetModel<TalentModel>(); } }
        PlayerPackModel pack { get { return ModelCenter.Instance.GetModel<PlayerPackModel>(); } }
        #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 = 1;
            Display();
            model.selectTalentTypeEvnet += OnSelectTalentTypeEvnet;
            model.selectSeriesEvent += OnSelectSeriesEvent;
            model.selectSkillEvent += OnSelectSkillEvent;
            model.talentSkillUpdate += TalentSkillUpdate;
            model.talentPointUpdate += TalentPointUpdate;
        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {
            model.selectTalentTypeEvnet -= OnSelectTalentTypeEvnet;
            model.selectSeriesEvent -= OnSelectSeriesEvent;
            model.selectSkillEvent -= OnSelectSkillEvent;
            model.talentSkillUpdate -= TalentSkillUpdate;
            model.talentPointUpdate -= TalentPointUpdate;
            for (int i = 0; i < m_TalentSeries.Length; i++)
            {
                m_TalentSeries[i].Dispose();
            }
            for (int i = 0; i < m_TalentSkills.Length; 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);

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

            if (talents != null && talents.Count > 0)
            {
                model.selectSkill = talents[0];
            }
            m_Scroller.verticalNormalizedPosition = 1;
            for (int i = 0; i < m_TalentSkills.Length; i++)
            {
                if (talents != null && i < talents.Count)
                {
                    m_TalentSkills[i].gameObject.SetActive(true);
                    m_TalentSkills[i].Display(talents[i]);
                }
                else
                {
                    m_TalentSkills[i].Dispose();
                    m_TalentSkills[i].gameObject.SetActive(false);
                }
            }
        }

        void DisplayTalentType()
        {
            var point = model.GetTalentTypePoint(model.selectTalentType == 1 ? 2 : 1);
            var job = PlayerDatas.Instance.baseData.Job;
            var talentTypeDisplay = Language.Get(StringUtility.Contact("TalentType_", job, "_", model.selectTalentType == 1 ? 2 : 1));
            m_TalentType.text = StringUtility.Contact(talentTypeDisplay, "（", point, "）");
            //m_TalentTitle.text = Language.Get(StringUtility.Contact("TalentType_", job, "_", model.selectTalentType));
        }

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

        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.RequireSeriesPoint();
                    if (requireSeriesPoint != 0 && index < m_SelectConditions.Length)
                    {
                        m_SelectConditions[index].gameObject.SetActive(true);
                        m_SelectConditions[index].text = StringUtility.Contact(model.GetSeriesPoint(talentConfig.type,
                            skillConfig.RequireSeries()), "/", requireSeriesPoint);
                        index++;
                    }
                }
                if (skillConfig != null && index < m_SelectConditions.Length)
                {
                    TalentSkill learnTalent;
                    if (skillConfig.LearnSkillReq != 0 && model.TryGetTalent(skillConfig.LearnSkillReq, out learnTalent))
                    {
                        var learnSkillConfig = Config.Instance.Get<SkillConfig>(skillConfig.LearnSkillReq);
                        m_SelectConditions[index].gameObject.SetActive(true);
                        m_SelectConditions[index].text = StringUtility.Contact(
                            "前置天赋： ", learnSkillConfig.SkillName, " ",
                            learnTalent.level, "/", learnSkillConfig.LearnSkillLV
                            );
                        index++;
                    }
                }
            }
            for (int i = index; i < m_SelectConditions.Length; i++)
            {
                m_SelectConditions[i].gameObject.SetActive(false);
            }
        }

        void DisplaySkillInfo()
        {
            TalentSkill talent;
            m_ContainerSelectSkill.gameObject.SetActive(false);
            if (model.TryGetTalent(model.selectSkill, out talent))
            {
                m_ContainerSelectSkill.gameObject.SetActive(true);
                var config = talent.GetSkillConfig(talent.level);
                m_SelectSkillIcon.SetSprite(config.IconName);
                m_SelectSkillLevel.text = StringUtility.Contact(talent.level, "/", talent.maxLevel);
                m_SelectSkillName.text = config.SkillName;
            }
        }

        void DisplaySkillEffect()
        {
            TalentSkill talent;
            if (model.TryGetTalent(model.selectSkill, out talent))
            {
                m_ContainerUnActive.gameObject.SetActive(talent.level == 0);
                m_ContainerActive.gameObject.SetActive(talent.level > 0);
                m_ContainerBetter.gameObject.SetActive(talent.level < talent.maxLevel);
                m_ContainerMax.gameObject.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();
        }

        private void SelectTalentType()
        {
            model.selectTalentType = model.selectTalentType == 1 ? 2 : 1;
        }

        private void DisplayLevelUp()
        {
            TalentSkill talent;
            if (model.TryGetTalent(model.selectSkill, out talent))
            {
                m_AddPointBtnText.text = talent.level >= talent.maxLevel ? "已满级" : "加点";
            }
        }

        private void AddPoint()
        {
            TalentSkill talent;
            if (model.TryGetTalent(model.selectSkill, out talent))
            {
                int error;
                if (!model.SatisfyLevelUp(model.selectSkill, out error))
                {
                    model.ProcessLevelUpError(error);
                    return;
                }
            }
        }

        private void ResetPoint()
        {
            var count = pack.GetItemCountByID(PackType.rptItem, model.talentResetBook);
            if (count > 0)
            {
                ConfirmCancel.ShowItemConfirm(Language.Get(""), model.talentResetBook, 1, () =>
                   {

                   });
            }
            else
            {
                if (model.storeId != 0)
                {
                    var storeConfig = Config.Instance.Get<StoreConfig>(model.storeId);
                    ConfirmCancel.ShowPopConfirm(Language.Get(""), Language.Get("", storeConfig.MoneyNumber), (bool isOk) =>
                       {
                           if (isOk)
                           {
                               ModelCenter.Instance.GetModel<StoreModel>().SendBuyShopItem(storeConfig, 1);
                           }
                       });
                }
            }
        }

        void DisplayTalentLayout(TalentTreeScriptable config)
        {
            m_Scroller.content.sizeDelta = config.contentSizeDelta;
            for (int i = 0; i < m_TalentSkills.Length; i++)
            {
                var element = config.GetTalentElement(i);
                m_TalentSkills[i].transform.localPosition = element.position;
            }
        }

#if UNITY_EDITOR
        [ContextMenu("应用位置数据")]
        void ApplyPositionToScriptable()
        {
            if (m_EditorScriptable == null)
            {
                return;
            }
            var count = 0;
            for (int i = 0; i < m_TalentSkills.Length; i++)
            {
                if (m_TalentSkills[i].gameObject.activeSelf)
                {
                    m_EditorScriptable.ApplyTalentElement(count, m_TalentSkills[i].transform.localPosition);
                    count++;
                }
            }
            m_EditorScriptable.SyncElementsCount(count);
        }
#endif
    }
}