//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Wednesday, February 20, 2019
//--------------------------------------------------------

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

namespace Snxxz.UI
{
    [XLua.Hotfix]
    public class TreasureSkillWin : Window
    {
        [SerializeField] ScrollerController m_Controller;

        [SerializeField] SkillWidget m_SkillNow;
        [SerializeField] SkillWidget m_SkillNext;
        [SerializeField] SkillExpertWidget m_SkillExpert;
        [SerializeField] Button m_ExpertSelect;
        [SerializeField] Transform m_ContainerMax;

        [SerializeField] ItemBehaviour m_Item;
        [SerializeField] Button m_LevelUp;
        [SerializeField] RedpointBehaviour m_LevelRedpoint;

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

        PackModel packModel
        {
            get { return ModelCenter.Instance.GetModel<PackModel>(); }
        }

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

        protected override void AddListeners()
        {
            m_Controller.OnRefreshCell += OnRefreshCell;
            m_LevelUp.AddListener(LevelUp);
            m_ExpertSelect.AddListener(ExpertSelect);
        }

        protected override void OnPreOpen()
        {
            SetDefaultSelect();

            Display();

            List<int> list;
            if (model.TryGetSkills(out list))
            {
                var index = list.IndexOf(model.selectSkill);
                if (index != -1)
                {
                    m_Controller.JumpIndex(index);
                }
            }

            model.treasureSkillRefresh += TreasureSkillRefresh;
            model.selectRefresh += SelectRefresh;
            model.skillLevelUpRefresh += SkillLevelUpRefresh;
            packModel.refreshItemCountEvent += RefreshItemCountEvent;
            model.expertSkillRefresh += ExpertSkillRefresh;
        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {
            model.treasureSkillRefresh -= TreasureSkillRefresh;
            model.selectRefresh -= SelectRefresh;
            model.skillLevelUpRefresh -= SkillLevelUpRefresh;
            packModel.refreshItemCountEvent -= RefreshItemCountEvent;
            model.expertSkillRefresh -= ExpertSkillRefresh;
            model.SetAlreadyRemind();
        }

        protected override void OnAfterClose()
        {
        }
        #endregion

        void SetDefaultSelect()
        {
            var _skill = 0;
            List<int> list;
            if (model.TryGetSkills(out list))
            {
                foreach (var skillId in list)
                {
                    TreasureSkill skill;
                    if (model.TryGetSkill(skillId, out skill))
                    {
                        if (_skill == 0 && skill.level > 0)
                        {
                            _skill = skillId;
                        }
                        if (skill.redpoint.state == RedPointState.Simple)
                        {
                            _skill = skillId;
                        }
                    }
                }
                if (_skill == 0)
                {
                    _skill = list[0];
                }
            }
            model.selectSkill = _skill;
        }

        private void Display()
        {
            DisplaySkills();
            DisplaySkillDetial();
            DisplayExpertSkill();
        }

        private void DisplaySkills()
        {
            List<int> list;
            m_Controller.Refresh();
            if (model.TryGetSkills(out list))
            {
                for (int i = 0; i < list.Count; i++)
                {
                    m_Controller.AddCell(ScrollerDataType.Header, list[i]);
                }
            }
            m_Controller.Restart();
        }

        void DisplaySkillDetial()
        {
            TreasureSkill skill;
            if (model.TryGetSkill(model.selectSkill, out skill))
            {
                var config = skill.GetSkillConfig(skill.level);
                if (config == null)
                {
                    return;
                }

                m_SkillNow.Display(skill.skillId, skill.level);

                bool isMax = skill.level >= skill.maxLevel;
                m_SkillNext.SetActive(!isMax);
                m_ContainerMax.gameObject.SetActive(isMax);

                if (!isMax)
                {
                    var upConfig = SkillConfig.Get(skill.skillId + skill.level);
                    m_Item.SetItem(upConfig.ExAttr4, upConfig.ExAttr5);
                    m_SkillNext.Display(skill.skillId, skill.level + 1);
                }
            }
        }

        void DisplayExpertSkill()
        {
            var skillId = 0;
            var level = 0;
            if (model.TryGetExpertSkill(model.selectSkill, out skillId))
            {
                TreasurePotential potential;
                if (model.TryGetPotential(skillId, out potential))
                {
                    level = potential.level;
                }
            }
            m_SkillExpert.Display(skillId, level);
        }

        private void ExpertSelect()
        {
            ExpertSkillSelectWin.selectSkillId = model.selectSkill;
            WindowCenter.Instance.Open<ExpertSkillSelectWin>();
        }

        private void LevelUp()
        {
            var error = 0;
            if (model.TryLevelUpTreasureSkill(model.selectSkill, out error))
            {
                var pak = new C0304_tagCAddSkillPoint();
                pak.SkillID = (ushort)model.selectSkill;
                GameNetSystem.Instance.SendInfo(pak);
            }
            else
            {
                model.DisplayLevelUpError(error);
            }
        }

        private void OnRefreshCell(ScrollerDataType type, CellView cell)
        {
            var skillCell = cell as TreasureSkillCell;
            skillCell.Display(cell.index);
        }

        private void TreasureSkillRefresh(int skillId)
        {
            m_Controller.m_Scorller.RefreshActiveCellViews();
            if (skillId == model.selectSkill)
            {
                DisplaySkillDetial();
            }
        }

        private void SelectRefresh()
        {
            m_Controller.m_Scorller.RefreshActiveCellViews();
            DisplaySkillDetial();
        }

        private void SkillLevelUpRefresh(int id)
        {
            if (model.selectSkill == id)
            {
                m_Controller.m_Scorller.RefreshActiveCellViews();
                DisplaySkillDetial();
            }
        }

        private void ExpertSkillRefresh()
        {
            DisplayExpertSkill();
        }

        private void RefreshItemCountEvent(PackType packType, int arg2, int itemId)
        {
            if (packType == PackType.Item && model.skillLevelUpItems.Contains(itemId))
            {
                DisplaySkillDetial();
            }
        }

        [Serializable]
        public class SkillWidget
        {
            [SerializeField] Transform m_Container;
            [SerializeField] Text m_SkillLevel;
            [SerializeField] Text m_SkillCoolDown;
            [SerializeField] Text m_SkillDesc;

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

            public void Display(int skillId, int level)
            {
                m_SkillLevel.text = Language.Get("SkillActLevel", level);
                TreasureSkill skill;
                model.TryGetSkill(skillId, out skill);
                var skillConfig = skill.GetSkillConfig(level);
                m_SkillCoolDown.text = skillConfig.CoolDownTime == 0 ? string.Empty
                    : Language.Get("L1065", skillConfig.CoolDownTime / 1000);
                m_SkillDesc.text = skillConfig.Description;
            }

            public void SetActive(bool active)
            {
                m_Container.gameObject.SetActive(active);
            }
        }

        [Serializable]
        public class SkillExpertWidget
        {
            [SerializeField] Image m_SkillIcon;
            [SerializeField] Transform m_ContainerReiki;
            [SerializeField] Text m_Reiki;
            [SerializeField] Text m_UnSelectRemind;
            [SerializeField] Text m_SwitchRemind;
            [SerializeField] Text m_Description;

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

            public void Display(int skillId, int level)
            {
                m_SkillIcon.gameObject.SetActive(skillId != 0);
                m_UnSelectRemind.gameObject.SetActive(skillId == 0);
                m_SwitchRemind.gameObject.SetActive(skillId != 0);
                m_Description.gameObject.SetActive(skillId != 0);
                m_ContainerReiki.gameObject.SetActive(skillId != 0);

                if (skillId != 0)
                {
                    SkillConfig skillConfig;
                    if (level == 0)
                    {
                        skillConfig = SkillConfig.Get(skillId);
                    }
                    else
                    {
                        skillConfig = SkillConfig.Get(skillId + level - 1);
                    }

                    m_SkillIcon.SetSprite(skillConfig.IconName);

                    var property = skillConfig.RequireProperty();
                    var propertyConfig = PlayerPropertyConfig.Get(property);
                    m_Reiki.text = propertyConfig.Name;
                    m_Reiki.color = UIHelper.GetPropertyColor(property);
                    if (level == 0)
                    {
                        var conditionLabel = string.Format("{0}灵根{1}激活", propertyConfig.Name, skillConfig.RequirePropertyValue());
                        conditionLabel = UIHelper.AppendColor(TextColType.Red, conditionLabel, true);
                        m_Description.text = StringUtility.Contact(skillConfig.Description, conditionLabel);
                        m_Description.color = UIHelper.s_Gray;
                    }
                    else
                    {
                        m_Description.text = skillConfig.Description;
                        m_Description.color = UIHelper.s_NavyBrown;
                    }
                }
            }
        }
    }

}