//--------------------------------------------------------
//    [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] Button m_SkillExpertBtn;
        [SerializeField] SkillExpertWidget m_SkillExpert;
        [SerializeField] RedpointBehaviour m_SelectRedpoint;
        [SerializeField] SkillExpertBehaviour[] m_SkillExpertBehaviours;

        [SerializeField] FunctionUnlockFlyObjectTarget m_FlyTarget;
        [SerializeField] Image m_DragSkillIcon;

        [SerializeField] float m_DisappearTime = 1f;

        FunctionUnlockFlyObject flyObject;

        public static int autoSelectSkill = 0;

        int functionGuideId = 0;

        float functionGuideTime = 0f;

        List<int> displaySkills = new List<int>();

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

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

        SkillModel skillModel { get { return ModelCenter.Instance.GetModel<SkillModel>(); } }

        ReikiRootModel reikiRootModel { get { return ModelCenter.Instance.GetModel<ReikiRootModel>(); } }
        TreasureModel treasureModel { get { return ModelCenter.Instance.GetModel<TreasureModel>(); } }

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

        protected override void AddListeners()
        {
            m_Controller.OnRefreshCell += OnRefreshCell;
            m_SkillExpertBtn.AddListener(OpenExpert);
        }

        protected override void OnPreOpen()
        {
            SetDefaultSelect();

            model.selectActivePriority = false;

            functionGuideId = 0;

            m_DragSkillIcon.gameObject.SetActive(false);

            if (flyObject != null)
            {
                GameObject.Destroy(flyObject.gameObject);
                flyObject = null;
            }

            Display();

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

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

            var index = displaySkills.IndexOf(model.selectSkill);
            if (index != -1)
            {
                var offset = 0f;
                m_Controller.JumpIndex(index, ref offset);
                var rect = m_Controller.mScrollRect.transform as RectTransform;
                m_Controller.JumpIndex(offset - rect.rect.height / 2 + 50, 0, EnhancedUI.EnhancedScroller.EnhancedScroller.TweenType.immediate);
            }
        }

        protected override void OnAfterOpen()
        {
            TreasureSkill treasureSkill;
            if (model.TryGetSkill(model.selectSkill, out treasureSkill))
            {
                if (treasureSkill.expertSelectRedpoint.state == RedPointState.Simple)
                {
                    PlaySelectGuide(true);
                }
            }
        }

        protected override void OnPreClose()
        {
            model.treasureSkillRefresh -= TreasureSkillRefresh;
            model.selectRefresh -= SelectRefresh;
            model.skillLevelUpRefresh -= SkillLevelUpRefresh;
            packModel.refreshItemCountEvent -= RefreshItemCountEvent;
            model.expertSkillRefresh -= ExpertSkillRefresh;
            WindowCenter.Instance.windowAfterCloseEvent -= WindowAfterCloseEvent;

            if (flyObject != null)
            {
                GameObject.Destroy(flyObject.gameObject);
                flyObject = null;
            }

            if (autoSelectSkill != 0)
            {
                var pak = new CA516_tagCMSelectSkillElement();
                pak.SkillTypeID = (uint)autoSelectSkill;
                pak.DoType = 1;
                GameNetSystem.Instance.SendInfo(pak);
            }

            if(NewBieCenter.Instance.inGuiding&& NewBieCenter.Instance.currentGuide == 62)
            {
                NewBieCenter.Instance.FinishNewBieGuide(62);
            }
        }

        protected override void OnAfterClose()
        {
        }
        #endregion

        void SetDefaultSelect()
        {

            displaySkills.Clear();

            var _skill = 0;
            List<int> list;
            if (model.TryGetSkills(out list))
            {
                displaySkills.AddRange(list);

                var index = displaySkills.FindIndex((x) =>
                  {
                      var treasureId = treasureModel.GetTreasureBySkillId(x);
                      var treasureConfig = TreasureConfig.Get(treasureId);
                      return treasureConfig.Category == (int)TreasureCategory.Fairy;
                  });

                if (index != -1)
                {
                    var skillId = displaySkills[index];
                    TreasureSkill treasureSkill;
                    var isActive = model.TryGetSkill(skillId, out treasureSkill)
                        && treasureSkill.level > 0;
                    displaySkills.RemoveAt(index);
                    if (isActive)
                    {
                        displaySkills.Insert(0, skillId);
                    }
                    else
                    {
                        displaySkills.Add(skillId);
                    }
                }

                foreach (var skillId in displaySkills)
                {
                    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 (model.selectActivePriority && skill.expertRedpoint.state == RedPointState.Simple)
                        {
                            _skill = skillId;
                            break;
                        }
                    }
                }
                if (_skill == 0)
                {
                    _skill = list[0];
                }
            }
            model.selectSkill = _skill;
        }

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

            TryStartGuide();
        }

        private void DisplaySkills()
        {
            m_Controller.Refresh();
            for (int i = 0; i < displaySkills.Count; i++)
            {
                m_Controller.AddCell(ScrollerDataType.Header, displaySkills[i]);
            }
            m_Controller.Restart();
        }

        void DisplaySkillDetial()
        {
            TreasureSkill skill;
            if (model.TryGetSkill(model.selectSkill, out skill))
            {
                m_SelectRedpoint.redpointId = skill.expertSelectRedpoint.id;

                var config = skill.GetSkillConfig(skill.level);
                if (config == null)
                {
                    return;
                }

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

        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);

            DisplayExpertSkills();
        }

        void DisplayExpertSkills()
        {
            TreasureSkill skill;
            if (model.TryGetSkill(model.selectSkill, out skill))
            {
                for (int i = 0; i < m_SkillExpertBehaviours.Length; i++)
                {
                    var potential = skill.potentials[i];
                    var level = 0;
                    model.TryGetExpertActiveLevel(potential.id, out level);
                    m_SkillExpertBehaviours[i].Display(potential.id, level);
                }
            }
        }

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

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

        private void WindowAfterCloseEvent(Window win)
        {
            if (win is ExpertSkillSelectWin)
            {
                TryAutoUse();
                TryStartGuide();
            }
        }

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

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

            TryStartGuide();

            TreasureSkill treasureSkill;
            if (model.TryGetSkill(model.selectSkill, out treasureSkill))
            {
                if (treasureSkill.expertSelectRedpoint.state == RedPointState.Simple)
                {
                    PlaySelectGuide(true);
                }
            }
        }

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

        private void ExpertSkillRefresh()
        {
            DisplayExpertSkill();
            m_Controller.m_Scorller.RefreshActiveCellViews();

            TryStartGuide();
        }

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

        void TrySwitchExpertSkill()
        {
            var des = RectTransformUtility.CalculateRelativeRectTransformBounds(this.transform, m_SkillExpert.dragAccepter);
            var src = RectTransformUtility.CalculateRelativeRectTransformBounds(this.transform, m_DragSkillIcon.rectTransform);
            var dis = Vector3.Distance(des.center, src.center);
            if (dis < m_SkillExpert.dragAccepter.rect.width / 2)
            {
                var skillId = 0;
                if (model.TryGetExpertSkill(model.selectSkill, out skillId)
                    && skillId == skillModel.skillDragId)
                {
                    return;
                }

                var pak = new CA516_tagCMSelectSkillElement();
                pak.SkillTypeID = (uint)skillModel.skillDragId;
                pak.DoType = 1;
                GameNetSystem.Instance.SendInfo(pak);
            }
        }

        void TryAutoUse()
        {
            var skill = 0;
            if (model.GetTotalExpertSkillLevel() == 1 &&
                !model.TryGetExpertSkill(model.selectSkill, out skill)
                && model.ExistAnyActiveExpert(model.selectSkill, out skill)
                && PlayerDatas.Instance.baseData.LV < reikiRootModel.resetReikiLimitLevel)
            {
                if (flyObject != null)
                {
                    GameObject.Destroy(flyObject.gameObject);
                    flyObject = null;
                }

                RectTransform parent = null;
                for (int i = 0; i < m_SkillExpertBehaviours.Length; i++)
                {
                    if (m_SkillExpertBehaviours[i].skillId == skill)
                    {
                        parent = m_SkillExpertBehaviours[i].flyContainer;
                    }
                }

                m_FlyTarget.IdList = new int[1] { skill };
                FunctionUnlockFlyObjectTargetCenter.Register(FunctionUnlockType.Skill, new int[] { skill }, m_FlyTarget);
                var instance = UIUtility.CreateWidget("SkillUnlockFlyObject", "SkillUnlockFlyObject");
                instance.transform.SetParentEx(parent, Vector3.zero, Quaternion.identity, Vector3.one);
                flyObject = instance.GetComponent<FunctionUnlockFlyObject>();
                flyObject.SetContent(FunctionUnlockType.Skill, skill);

                autoSelectSkill = skill;

                flyObject.Begin(() =>
                {
                    var pak = new CA516_tagCMSelectSkillElement();
                    pak.SkillTypeID = (uint)skill;
                    pak.DoType = 1;
                    GameNetSystem.Instance.SendInfo(pak);

                    autoSelectSkill = 0;
                });
            }
        }

        void TryStartGuide()
        {
            if (NewBieCenter.Instance.inGuiding)
            {
                return;
            }
            if (!NewBieCenter.Instance.IsGuideCompleted(62))
            {
                var treasureModel = ModelCenter.Instance.GetModel<TreasureModel>();
                var treasureId = treasureModel.GetTreasureBySkillId(model.selectSkill);
                if (treasureId == 102)
                {
                    var skill = 0;
                    if (model.ExistAnyActiveExpert(model.selectSkill)
                        && !WindowCenter.Instance.IsOpen<ExpertSkillSelectWin>()
                        && !model.TryGetExpertSkill(model.selectSkill, out skill))
                    {
                        NewBieCenter.Instance.StartNewBieGuide(62);
                    }
                }
            }
        }

        private void OpenExpert()
        {
            var skillId = 0;
            if (model.TryGetExpertSkill(model.selectSkill, out skillId))
            {
                ExpertSkillSelectWin.skillId = skillId;
                WindowCenter.Instance.Open<ExpertSkillSelectWin>();
            }
            else
            {
                var expertSkill = 0;
                if (model.ExistAnyActiveExpert(model.selectSkill, out expertSkill))
                {
                    PlaySelectGuide();
                }
                else
                {
                    SysNotifyMgr.Instance.ShowTip("NoneOfAnyActiveExpert");
                }
            }
        }

        private void PlaySelectGuide(bool disappear = false)
        {
            if (NewBieCenter.Instance.inGuiding)
            {
                return;
            }

            List<int> indexs = new List<int>();
            TreasureSkill treasureSkill;
            if (model.TryGetSkill(model.selectSkill, out treasureSkill))
            {
                for (int i = 0; i < treasureSkill.potentials.Count; i++)
                {
                    var level = 0;
                    if (model.TryGetExpertActiveLevel(treasureSkill.potentials[i].id, out level)
                        && level > 0)
                    {
                        indexs.Add(i);
                    }
                }
            }

            if (indexs.Count == 0)
            {
                return;
            }

            var index = indexs[UnityEngine.Random.Range(0, indexs.Count)];
            functionGuideTime = Time.time;
            switch (index)
            {
                case 0:
                    if (disappear)
                    {
                        functionGuideId = 65;
                    }
                    NewBieCenter.Instance.StartNewBieGuide(65);
                    break;
                case 1:
                    if (disappear)
                    {
                        functionGuideId = 63;
                    }
                    NewBieCenter.Instance.StartNewBieGuide(63);
                    break;
                case 2:
                    if (disappear)
                    {
                        functionGuideId = 64;
                    }
                    NewBieCenter.Instance.StartNewBieGuide(64);
                    break;
            }
        }

        protected override void LateUpdate()
        {
            base.LateUpdate();
            if (skillModel.skillDraging)
            {
                if (!m_DragSkillIcon.gameObject.activeSelf)
                {
                    m_DragSkillIcon.gameObject.SetActive(true);
                    var config = SkillConfig.Get(skillModel.skillDragId);
                    if (config != null)
                    {
                        m_DragSkillIcon.SetSprite(config.IconName);
                    }
                }
                Vector2 _pos;
                if (RectTransformUtility.ScreenPointToLocalPointInRectangle(this.transform as RectTransform,
                    Input.mousePosition, CameraManager.uiCamera, out _pos))
                {
                    m_DragSkillIcon.rectTransform.localPosition = _pos;
                }

                if (Input.GetMouseButtonUp(0))
                {
                    skillModel.skillDraging = false;
                    TrySwitchExpertSkill();
                    m_DragSkillIcon.gameObject.SetActive(false);
                }
            }

            if (functionGuideId != 0)
            {
                if (Time.time - functionGuideTime >= m_DisappearTime)
                {
                    NewBieCenter.Instance.FinishNewBieGuide(functionGuideId);
                    functionGuideId = 0;
                }
            }
        }

        [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] RectTransform m_DragAccepter;
            [SerializeField] Image m_SkillIcon;
            [SerializeField] Text m_SkillName;
            [SerializeField] Transform m_ContainerReikiIcon;
            [SerializeField] Image[] m_ReikiIcons;
            [SerializeField] Text m_UnSelectRemind;
            [SerializeField] Text m_Description;

            public RectTransform dragAccepter
            {
                get { return m_DragAccepter; }
            }

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

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


                m_ContainerReikiIcon.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);
                    m_SkillName.text = skillConfig.SkillName;

                    var property = skillConfig.RequireProperty();
                    var propertyConfig = PlayerPropertyConfig.Get(property);

                    m_ReikiIcons[0].gameObject.SetActive(property == (int)PropertyType.Mater);
                    m_ReikiIcons[1].gameObject.SetActive(property == (int)PropertyType.Wood);
                    m_ReikiIcons[2].gameObject.SetActive(property == (int)PropertyType.Water);
                    m_ReikiIcons[3].gameObject.SetActive(property == (int)PropertyType.Fire);
                    m_ReikiIcons[4].gameObject.SetActive(property == (int)PropertyType.Earth);

                    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_BrightWhiteColor;
                    }
                    else
                    {
                        m_Description.text = skillConfig.Description;
                        m_Description.color = UIHelper.s_NavyBrown;
                    }
                }
            }
        }
    }
}