//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, March 11, 2019
//--------------------------------------------------------

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

namespace Snxxz.UI
{

    public class EquipStrengthWin : Window
    {
        [SerializeField] ScrollerController m_Controller;

        [SerializeField] Transform m_ContainerStrength;
        [SerializeField] Transform m_ContainerEmpty;

        [SerializeField] GameObject m_NotEquipped;//未装备
        [SerializeField] EquipStrengthFull m_EquipStrengthFull;//满级
        [SerializeField] EquipStrengthUpper m_EquipStrengthUpper;//强化上限
        [SerializeField] EquipStrengthRein m_EquipStrengthRein;//可强化
        [SerializeField] EquipEvolution m_EquipEvolution;//进阶
        [SerializeField] GameObject m_BottomFrame;
        [SerializeField] Button m_StrengBtn;
        [SerializeField] Button m_AutomaticBtn;
        [SerializeField] Button m_StopBtn;

        [SerializeField] RedpointBehaviour m_AdvanceRedpoint;
        [SerializeField] RedpointBehaviour m_StrengthRedpoint;

        [SerializeField] UIEffect m_UIEffect1A;
        [SerializeField] UIEffect m_UIEffect1B;
        [SerializeField] UIEffect m_UIEffect1C;

        EquipStrengthModel model { get { return ModelCenter.Instance.GetModel<EquipStrengthModel>(); } }
        EquipModel equipModel { get { return ModelCenter.Instance.GetModel<EquipModel>(); } }
        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        EquipStarModel equipStarModel { get { return ModelCenter.Instance.GetModel<EquipStarModel>(); } }
        PlayerMainDate mainModel { get { return ModelCenter.Instance.GetModel<PlayerMainDate>(); } }

        float customDelayTime = 0f;
        float customPowerUpDelay = 0.5f;

        bool m_IsAutomaticBool = false;
        private bool IsAutomaticBool
        {
            get { return m_IsAutomaticBool; }
            set
            {
                if (m_IsAutomaticBool != value)
                {
                    m_IsAutomaticBool = value;
                    if (value)
                    {
                        recordFightPower = PlayerDatas.Instance.baseData.FightPoint;
                    }
                    else
                    {
                        customDelayTime = Time.time;
                        var power = recordFightPower;
                        Clock.AlarmAfter(customPowerUpDelay, () =>
                         {
                             var powerUp = PlayerDatas.Instance.baseData.FightPoint - power;
                             if (powerUp > 0)
                             {
                                 mainModel.CustomPowerUp((int)powerUp);
                             }
                         });
                        recordFightPower = 0;
                    }
                }
            }
        }

        public float WaitTime = 0.1f;
        private float Times = 0f;

        uint recordFightPower = 0;

        bool selectRedpointable = false;

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

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

        protected override void AddListeners()
        {
            m_Controller.OnRefreshCell += OnRefreshCell;
            m_StrengBtn.AddListener(OnClickStrengBtn);
            m_AutomaticBtn.AddListener(OnClickAutomaticBtn);
            m_StopBtn.AddListener(OnClickStopBtn);
        }

        protected override void OnPreOpen()
        {
            model.IsChangeBool = true;
            m_IsAutomaticBool = false;
            Times = 0f;
            m_StopBtn.gameObject.SetActive(false);
            m_AutomaticBtn.gameObject.SetActive(true);

            var selectEquip = OpenSelect();//默认选择                  
            DisplayEquips();
            SetStrengthenedState();
            model.SelectEquipRefresh += SelectEquipRefresh;
            model.SelectLevelRefresh += SelectLevelRefresh;
            model.EquipStrengthUpdate += EquipStrengthUpdate;
            model.EquipStrengthLvUpdate += EquipStrengthLvUpdate;
            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;
            mainModel.customDisplayPower += CustomDisplayPower;

            m_Controller.JumpIndex(GetJumpIndex(model.SelectLevel, model.SelectEquipPlace, selectEquip));
        }


        protected override void OnAfterOpen()
        {
            RedpointCenter.Instance.redpointValueChangeEvent += RedpointValueChangeEvent;
        }

        protected override void OnPreClose()
        {
            model.SelectEquipRefresh -= SelectEquipRefresh;
            model.SelectLevelRefresh -= SelectLevelRefresh;
            model.EquipStrengthUpdate -= EquipStrengthUpdate;
            model.EquipStrengthLvUpdate -= EquipStrengthLvUpdate;
            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;
            RedpointCenter.Instance.redpointValueChangeEvent -= RedpointValueChangeEvent;
            mainModel.customDisplayPower -= CustomDisplayPower;

            model.SetDayRemind();

            IsAutomaticBool = false;
        }

        protected override void OnAfterClose()
        {
        }
        protected override void LateUpdate()
        {
            if (IsAutomaticBool)
            {
                Times += Time.deltaTime;
                var isBool = StrengtheBool();
                var upperLimitBool = UpperLimitBool();
                if (Times >= WaitTime && isBool && upperLimitBool)
                {
                    Times = 0;
                    int itemIndex = EquipPlaceMapConfig.GetServerPlace(model.SelectLevel, model.SelectEquipPlace);
                    model.SendEquip(itemIndex);
                }
                else if (!isBool || !upperLimitBool)
                {
                    IsAutomaticBool = false;
                    OnClickStopBtn();
                }
            }
            else
            {
                Times = 0f;
            }
        }
        #endregion

        private bool CustomDisplayPower()
        {
            return IsAutomaticBool || (Time.time - customDelayTime) < customPowerUpDelay;
        }

        int GetJumpIndex(int selectLevel, int selectPlace, bool selectEquip)
        {
            var jumpIndex = 0;
            var equipSets = equipModel.GetAllEquipSets();
            foreach (var level in equipSets)
            {
                if (level > selectLevel)
                {
                    return jumpIndex;
                }
                var equipSet = equipModel.GetEquipSet(level);
                if (equipSet == null)
                {
                    continue;
                }
                if (equipSet.unLocked)
                {
                    if (selectLevel == level && !selectEquip)
                    {
                        return jumpIndex;
                    }
                    jumpIndex++;
                    if (model.SelectLevel == level)
                    {
                        foreach (var place in m_Sorts)
                        {
                            if (equipSet.IsSlotUnLocked(place))
                            {
                                if (selectLevel == level && selectPlace == place)
                                {
                                    return jumpIndex;
                                }
                                jumpIndex++;
                            }
                        }
                    }
                }
            }
            return 0;
        }

        private void OnClickStrengBtn()
        {
            if (StrengtheBool())
            {
                int itemIndex = EquipPlaceMapConfig.GetServerPlace(model.SelectLevel, model.SelectEquipPlace);
                model.SendEquip(itemIndex);
            }

        }
        private void OnClickAutomaticBtn()
        {
            if (StrengtheBool())
            {
                IsAutomaticBool = true;
                m_StopBtn.gameObject.SetActive(true);
                m_AutomaticBtn.gameObject.SetActive(false);
            }

        }
        private void OnClickStopBtn()
        {
            IsAutomaticBool = false;
            m_StopBtn.gameObject.SetActive(false);
            m_AutomaticBtn.gameObject.SetActive(true);

        }

        private void EquipStrengthLvUpdate()
        {
            if (!m_UIEffect1B.IsPlaying)
            {
                m_UIEffect1B.Play();
            }
        }

        private void EquipStrengthUpdate()
        {
            if (!m_UIEffect1A.IsPlaying)
            {
                m_UIEffect1A.Play();
            }
            m_UIEffect1C.Play();
            if (model.SelectLevel != -1)
            {
                SetStrengthenedState();
                m_Controller.m_Scorller.RefreshActiveCellViews();
            }
        }
        void DisplayEquips()
        {
            m_Controller.Refresh();
            var equipSets = equipModel.GetAllEquipSets();
            foreach (var level in equipSets)
            {
                var equipSet = equipModel.GetEquipSet(level);
                if (equipSet == null)
                {
                    continue;
                }
                if (equipSet.unLocked)
                {
                    m_Controller.AddCell(ScrollerDataType.Header, level);
                    if (model.SelectLevel == level)
                    {
                        m_Sorts.Clear();
                        m_Sorts.AddRange(model.equipPlaces);
                        m_Sorts.Sort(EquipCompare);
                        foreach (var place in m_Sorts)
                        {
                            if (equipSet.IsSlotUnLocked(place))
                            {
                                m_Controller.AddCell(ScrollerDataType.Normal, level * 1000 + place);
                            }
                        }
                    }
                }
            }
            m_Controller.Restart();
        }

        private int EquipCompare(int x, int y)
        {
            var x_state = model.GetEquipStrengthState(new Int2(model.SelectLevel, x));
            var y_state = model.GetEquipStrengthState(new Int2(model.SelectLevel, y));
            if (x_state != y_state)
            {
                return x_state.CompareTo(y_state);
            }
            return x.CompareTo(y);
        }

        private void SelectEquipRefresh()
        {
            m_Controller.m_Scorller.RefreshActiveCellViews();
            model.IsChangeBool = true;
            SetStrengthenedState();
            if (IsAutomaticBool)
            {
                Times = 0f;
                OnClickStopBtn();
                IsAutomaticBool = false;
            }
        }

        private void SelectLevelRefresh()
        {
            model.IsChangeBool = true;
            if (IsAutomaticBool)
            {
                Times = 0f;
                OnClickStopBtn();
                IsAutomaticBool = false;
            }
            DisplayEquips();
            if (model.SelectLevel != -1)
            {
                model.SelectEquipPlace = m_Sorts[0];
            }
            SetStrengthenedState();
        }

        private void OnRefreshCell(ScrollerDataType type, CellView cell)
        {
            switch (type)
            {
                case ScrollerDataType.Header:
                    var equipGemHeadCell = cell as EquipStrengthHeadBehaviour;
                    equipGemHeadCell.Display(cell.index);
                    break;
                case ScrollerDataType.Normal:
                    var level = cell.index / 1000;
                    var place = cell.index % 1000;
                    var equipSelectCell = cell as EquipStrengthSelectBehaviour;
                    equipSelectCell.Display(level, place);
                    break;
            }
        }

        private void SetStrengthenedState()
        {
            if (model.SelectLevel == -1)
            {
                m_ContainerEmpty.gameObject.SetActive(true);
                m_ContainerStrength.gameObject.SetActive(false);
                return;
            }

            m_ContainerEmpty.gameObject.SetActive(false);
            m_ContainerStrength.gameObject.SetActive(true);

            EquipStrengthModel.EquipStrengthRedpoint redpoint;
            if (model.TryGetRedpoint(model.SelectLevel, model.SelectEquipPlace, out redpoint))
            {
                m_AdvanceRedpoint.redpointId = redpoint.advanceRedpoint.id;
                m_StrengthRedpoint.redpointId = redpoint.strengthRedpoint.id;
                selectRedpointable = redpoint.strengthRedpoint.state == RedPointState.Simple;
            }

            var equipGuid = equipModel.GetEquip(new Int2(model.SelectLevel, model.SelectEquipPlace));

            var state = model.GetEquipStrengthState(new Int2(model.SelectLevel, model.SelectEquipPlace));

            m_NotEquipped.SetActive(state == 3);

            m_EquipStrengthFull.gameObject.SetActive(state == 2);
            m_EquipStrengthUpper.gameObject.SetActive(state == 1);
            m_EquipStrengthRein.gameObject.SetActive(state == 0);
            m_EquipEvolution.gameObject.SetActive(state != 3);
            m_BottomFrame.gameObject.SetActive(state == 1 || state == 0);

            if (state != 3)
            {
                var advancedLv = 0;
                var serverPlace = EquipPlaceMapConfig.GetServerPlace(model.SelectLevel, model.SelectEquipPlace);
                if (model.EquipStrengthDic.ContainsKey(serverPlace))
                {
                    advancedLv = model.EquipStrengthDic[serverPlace].EvolveLV;
                }
                m_EquipEvolution.SetEquipEvolution(model.SelectEquipPlace, advancedLv);
            }

            switch (state)
            {
                case 0:
                    m_EquipStrengthRein.SetEquipStrengthRein(equipGuid, model.SelectLevel, model.SelectEquipPlace);
                    break;
                case 1:
                    m_EquipStrengthUpper.SetEquipStrengthUpper(equipGuid, model.SelectLevel, model.SelectEquipPlace);
                    break;
                case 2:
                    m_EquipStrengthFull.SetEquipStrengthFull(equipGuid, model.SelectLevel, model.SelectEquipPlace);
                    break;
            }
        }

        private bool OpenSelect()
        {
            model.SelectLevel = -1;
            model.SelectEquipPlace = -1;

            if (!model.jumpEquipPosition.Equals(Int2.zero))
            {
                model.SelectLevel = model.jumpEquipPosition.x;
                model.SelectEquipPlace = model.jumpEquipPosition.y;
                model.jumpEquipPosition = Int2.zero;
                return true;
            }

            var equipSets = equipModel.GetAllEquipSets();
            foreach (var equipSet in equipSets)
            {
                var places = model.equipPlaces;
                foreach (var place in places)
                {
                    EquipStrengthModel.EquipStrengthRedpoint redpoint;
                    if (model.TryGetRedpoint(equipSet, place, out redpoint)
                        && redpoint.redpoint.state == RedPointState.Simple)
                    {
                        model.SelectLevel = equipSet;
                        model.SelectEquipPlace = place;
                        return true;
                    }
                }
            }

            var minStrengthLevel = int.MaxValue;
            var minSelect = Int2.zero;
            foreach (var level in equipSets)
            {
                var equipSet = equipModel.GetEquipSet(level);
                if (equipSet == null)
                {
                    continue;
                }
                model.SelectLevel = level;
                var places = model.equipPlaces;
                places.Sort(EquipCompare);
                foreach (var place in places)
                {
                    if (minSelect.x == 0)
                    {
                        minSelect.x = level;
                        minSelect.y = place;
                    }
                    var state = model.GetEquipStrengthState(new Int2(level, place));
                    if (state == 3)
                    {
                        continue;
                    }
                    var strengthLevel = model.GetStrengthLevel(level, place);
                    if (strengthLevel < minStrengthLevel && state == 0)
                    {
                        minStrengthLevel = strengthLevel;
                        minSelect.x = level;
                        minSelect.y = place;
                    }
                }
            }
            model.SelectLevel = minSelect.x;
            model.SelectEquipPlace = minSelect.y;
            return minStrengthLevel != int.MaxValue;
        }

        private bool StrengtheBool()
        {

            if (m_EquipStrengthUpper.gameObject.activeSelf)
            {
                int equipType = EquipStrengthModel.GetEquipStrengthType(model.SelectEquipPlace);
                var equipPosition = new Int2(model.SelectLevel, model.SelectEquipPlace);
                var star = equipStarModel.GetEquipStarLevel(equipPosition);
                var equipGuid = equipModel.GetEquip(equipPosition);
                var item = packModel.GetItemByGuid(equipGuid);
                var maxStar = EquipStarModel.GetMaxStarLevel(item.config.ItemColor, model.SelectEquipPlace);
                star = Mathf.Min(star, maxStar);
                var equipMaxLv = model.GetEquipLevelMax(equipType, star);
                SysNotifyMgr.Instance.ShowTip("EquipStrengthLimitError_1", star, equipMaxLv);
                return false;
            }

            var itemPlus = model.GetEquipConfig(model.SelectLevel, model.SelectEquipPlace);
            if (itemPlus == null)
            {
                return false;
            }

            ulong money = UIHelper.GetMoneyCnt(3);
            ulong needMoney = (ulong)itemPlus.costCount;
            if (money < needMoney)
            {
                ItemTipUtility.Show(2100);
                return false;
            }

            return true;
        }
        private bool UpperLimitBool()
        {
            bool isBool = false;
            var equipPosition = new Int2(model.SelectLevel, model.SelectEquipPlace);
            int equipIndex = EquipSet.ClientPlaceToServerPlace(equipPosition);
            int star = equipStarModel.GetEquipStarLevel(equipPosition);
            int equipLv = 0;
            if (model.EquipStrengthDic.ContainsKey(equipIndex))//获取当前强化等级
            {
                equipLv = model.EquipStrengthDic[equipIndex].StrengthLevel;
            }
            int equipType = EquipStrengthModel.GetEquipStrengthType(model.SelectEquipPlace);
            var itemPlusMaxConfig = ItemPlusMaxConfig.GetEquipTypeAndEquipStar(equipType, star);//获取强化等级上限值
            if (itemPlusMaxConfig.levelMax > equipLv)
            {
                isBool = true;
            }
            else
            {
                isBool = false;
            }

            return isBool;
        }

        private void PlayerDataRefreshEvent(PlayerDataType dataType)
        {
            if (dataType == PlayerDataType.Silver)
            {
                m_EquipStrengthRein.DisplayMoney();
                m_EquipStrengthUpper.DisplayMoney();
            }
        }

        private void RedpointValueChangeEvent(int id)
        {
            if (model.SelectLevel != -1)
            {
                EquipStrengthModel.EquipStrengthRedpoint redpoint;
                if (model.TryGetRedpoint(model.SelectLevel, model.SelectEquipPlace, out redpoint))
                {
                    if (selectRedpointable && redpoint.strengthRedpoint.state != RedPointState.Simple)
                    {
                        if (IsAutomaticBool)
                        {
                            Int2 position;
                            if (OnRedpointSelect(out position))
                            {
                                OnClickStopBtn();

                                model.SelectLevel = position.x;
                                model.SelectEquipPlace = position.y;

                                if (!m_Controller.IsDisplay(position.x * 1000 + position.y))
                                {
                                    m_Controller.JumpIndex(GetJumpIndex(model.SelectLevel, model.SelectEquipPlace, true));
                                }
                            }
                        }
                    }
                }
            }
        }

        bool OnRedpointSelect(out Int2 position)
        {
            position = default(Int2);
            var equipSets = equipModel.GetAllEquipSets();
            foreach (var equipSet in equipSets)
            {
                var places = model.equipPlaces;
                foreach (var place in places)
                {
                    EquipStrengthModel.EquipStrengthRedpoint redpoint;
                    if (model.TryGetRedpoint(equipSet, place, out redpoint)
                        && redpoint.strengthRedpoint.state == RedPointState.Simple)
                    {
                        position = new Int2()
                        {
                            x = equipSet,
                            y = place,
                        };
                        return true;
                    }
                }
            }
            return false;
        }
    }
}