using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using TableConfig;
using UnityEngine;
using UnityEngine.UI;
namespace Snxxz.UI
{
    public class RuneBreakWin : Window
    {
        [SerializeField] Image itemIcon0;
        [SerializeField] Image itemIcon1;
        [SerializeField] Text itemNum0;
        [SerializeField] Text itemNum1;
        [SerializeField] Text itemGet0;
        [SerializeField] Text itemGet1;
        [SerializeField] Button breakBtn;
        [SerializeField] ScrollerController m_Controller;
        [SerializeField] List<Button> m_CheckBtns;
        [SerializeField] List<Image> m_CheckMarks;
        [SerializeField] UIEffect m_FlutterEffect;
        [SerializeField] UIEffect m_AbsorbEffect;
        [SerializeField] Button m_JumpBtn0;
        [SerializeField] Button m_JumpBtn1;
        [SerializeField] RectTransform m_ContainerRuneSoul;
        [SerializeField] Text m_RuneSoulAdd;

        private List<bool> m_Checks = new List<bool>();
        private List<ushort> m_BreakRunes = new List<ushort>();
        private bool m_PlayerBreakEffect = false;

        RuneModel m_Model;
        RuneModel model
        {
            get
            {
                return m_Model ?? (m_Model = ModelCenter.Instance.GetModel<RuneModel>());
            }
        }

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

        RuneComposeModel m_RuneComposeModel;
        RuneComposeModel runeComposeModel
        {
            get
            {
                return m_RuneComposeModel ?? (m_RuneComposeModel = ModelCenter.Instance.GetModel<RuneComposeModel>());
            }
        }

        private void OnRefreshPack()
        {
            UpdateRuneBreak();
            OnUpdateItemNum();
        }
        private void OnBreakBtn()
        {
            m_BreakRunes.Clear();
            for (int i = 0; i < model.runeBreakEnableDict.Count; i++)
            {
                if (model.runeBreakEnableDict[i])
                {
                    RuneData data = model.runeBreakList[i];
                    m_BreakRunes.Add((ushort)data.index);
                }
            }
            if (m_BreakRunes.Count < 1)
            {
                MessageWin.Inst.ShowFixedTip(Language.Get("L1059"));
                return;
            }
            ushort[] placeIndexs = null;
            while (m_BreakRunes.Count > 0)
            {
                m_PlayerBreakEffect = true;
                CA566_tagCMRuneDecompose resolve = new CA566_tagCMRuneDecompose();
                resolve.QualityCnt = 0;
                resolve.QualityList = new byte[0];
                if (m_BreakRunes.Count > 50)
                {
                    placeIndexs = new ushort[50];
                    resolve.Count = 50;
                    m_BreakRunes.CopyTo(0, placeIndexs, 0, 50);
                    m_BreakRunes.RemoveRange(0, 50);
                }
                else
                {
                    placeIndexs = new ushort[m_BreakRunes.Count];
                    resolve.Count = (byte)placeIndexs.Length;
                    m_BreakRunes.CopyTo(placeIndexs);
                    m_BreakRunes.Clear();
                }
                resolve.PlaceIndexList = placeIndexs;
                GameNetSystem.Instance.SendInfo(resolve);
            }
        }
        private void OnClickCheck(int type)
        {
            bool check = m_Checks[type - 1];
            OnCheck(type, !check);
        }
        private void OnCheck(int type, bool check)
        {
            m_Checks[type - 1] = check;
            m_CheckMarks[type - 1].gameObject.SetActive(m_Checks[type - 1]);
            for (int i = 0; i < model.runeBreakList.Count; i++)
            {
                RuneData _data = model.runeBreakList[i];
                var _itemCfg = ConfigManager.Instance.GetTemplate<ItemConfig>(_data.id);
                if (_itemCfg.ItemColor == type && _itemCfg.Type == RuneModel.RUNE_TYPE)
                {
                    if (!model.runeBreakEnableDict.ContainsKey(i))
                    {
                        model.runeBreakEnableDict.Add(i, check);
                    }
                    else
                    {
                        model.runeBreakEnableDict[i] = check;
                    }
                }
            }
            m_Controller.m_Scorller.RefreshActiveCellViews();
            OnUpdateItemNum();
        }

        void UpdateRuneBreak(bool _force = false)
        {
            if (model.runeBreakRects.Count > 0 && m_PlayerBreakEffect)
            {
                float _time = 0.0f;
                for (int i = 0; i < model.runeBreakRects.Count; i++)
                {
                    //model.runeBreakRects[i].gameObject.SetActive(false);
                    var _uieffect = EffectMgr.Instance.PlayUIEffect(1007, 2500, model.runeBreakRects[i].parent, false);
                    _time = _uieffect != null ? _uieffect.duration : 0.0f;
                    _uieffect.target.transform.localPosition = model.runeBreakRects[i].localPosition;
                }
                m_PlayerBreakEffect = false;
                StartCoroutine(Co_PlayEffect(_time));
            }
            else
            {
                RefreshBreak();
            }
        }

        void RefreshBreak()
        {
            model.runeBreakRects.Clear();
            DisplayRunes();
            SetBreakDefault();
        }

        void SetBreakDefault()
        {
            model.runeBreakEnableDict.Clear();
            for (int i = 0; i < model.runeBreakList.Count; i++)
            {
                if (!model.runeBreakEnableDict.ContainsKey(i))
                {
                    RuneData _data = model.runeBreakList[i];
                    var _itemCfg = ConfigManager.Instance.GetTemplate<ItemConfig>(_data.id);
                    if (_itemCfg.Type == RuneModel.RUNE_CREAMTYPE)
                    {
                        model.runeBreakEnableDict.Add(i, true);
                    }
                    else
                    {
                        model.runeBreakEnableDict.Add(i, false);
                    }
                }
            }
            OnCheck(1, m_Checks[0]);
            OnCheck(2, m_Checks[1]);
            OnCheck(3, m_Checks[2]);
            OnCheck(4, m_Checks[3]);
        }

        IEnumerator Co_PlayEffect(float _t)
        {
            yield return WaitingForSecondConst.GetWaitForSeconds(_t);
            RefreshBreak();
            m_FlutterEffect.Play();
            m_FlutterEffect.OnComplete = OnFlutterComplete;
        }

        private void OnFlutterComplete()
        {
            m_AbsorbEffect.Play();
        }

        void DisplayRunes()
        {
            m_Controller.Refresh();
            model.runeBreakList = model.GetPackRune().Values.ToList();
            if (model.runeBreakList != null && model.runeBreakList.Count > 0)
            {
                model.runeBreakList.Sort(Compare);
                int _line = Mathf.CeilToInt((float)model.runeBreakList.Count / 4);
                for (int i = 0; i < _line; i++)
                {
                    m_Controller.AddCell(ScrollerDataType.Normal, i);
                }
            }
            m_Controller.Restart();
        }

        void OnUpdateItemNum()
        {
            float _itemCnt = 0;
            float _magicCnt = 0;
            float _soulCnt = 0;
            foreach (int key in model.runeBreakEnableDict.Keys)
            {
                if (!model.runeBreakEnableDict[key])
                {
                    continue;
                }
                var _data = model.runeBreakList[key];
                _itemCnt += model.GetRuneBreakExp(_data);
                _soulCnt += model.GetRuneSoulBreakExp(_data);
                if (runeComposeModel.m_RuneBothPropertys.Contains(_data.id))
                {
                    var _composeCfg = ConfigManager.Instance.GetTemplate<RuneComposeConfig>(_data.id);
                    _magicCnt += (_composeCfg == null ? 0 : _composeCfg.NeedMJ);
                }
            }
            itemNum1.text = UIHelper.ReplaceLargeNum(model.RuneSplinters);
            itemNum0.text = UIHelper.ReplaceLargeNum(PlayerDatas.Instance.extersion.magicEssence);
            itemGet1.gameObject.SetActive(_itemCnt != 0);
            itemGet0.gameObject.SetActive(_magicCnt != 0);
            itemGet0.text = StringUtility.Contact("+", UIHelper.ReplaceLargeNum(_magicCnt));
            itemGet1.text = StringUtility.Contact("+", UIHelper.ReplaceLargeNum((int)_itemCnt));
            m_RuneSoulAdd.text = Language.Get("RuneSoul", UIHelper.ReplaceLargeNum((int)_soulCnt));
        }

        private void OnJumpRuneTower()
        {
            WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.RuneTower);
        }

        private void PlayerDataRefreshInfoEvent(PlayerDataRefresh type)
        {
            if (type == PlayerDataRefresh.MagicEssence)
            {
                OnUpdateItemNum();
            }
        }

        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
            breakBtn.onClick.AddListener(OnBreakBtn);
            for (int i = 0; i < m_CheckBtns.Count; i++)
            {
                int _type = i + 1;
                m_CheckBtns[i].onClick.AddListener(() =>
                {
                    OnClickCheck(_type);
                });
                m_Checks.Add(i == 0);
            }
            m_JumpBtn0.onClick.AddListener(OnJumpRuneTower);
            m_JumpBtn1.onClick.AddListener(OnJumpRuneTower);
        }

        protected override void OnPreOpen()
        {
            model.OnRefreshRunePack += OnRefreshPack;
            model.OnRefreshRuneExp += OnUpdateItemNum;
            model.OnRefreshBreakRune += OnUpdateItemNum;
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent += PlayerDataRefreshInfoEvent;
            m_PlayerBreakEffect = false;
            UpdateRuneBreak(true);
            m_ContainerRuneSoul.gameObject.SetActive(treasureModel.IsGetTreasurePrivilege(TreasurePrivilege.RuneBreakExpAdd));
        }

        protected override void OnAfterOpen()
        {
            HandleAchievement();
        }

        protected override void OnPreClose()
        {
            m_PlayerBreakEffect = false;
            model.OnRefreshRunePack -= OnRefreshPack;
            model.OnRefreshRuneExp -= OnUpdateItemNum;
            model.OnRefreshBreakRune -= OnUpdateItemNum;
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent -= PlayerDataRefreshInfoEvent;
        }

        protected override void OnAfterClose()
        {

        }

        void HandleAchievement()
        {
            if (AchievementGoto.achievementType == AchievementGoto.RuneResolve)
            {
                var _effect = AchievementGuideEffectPool.Require(1);
                _effect.transform.SetParentEx(breakBtn.transform, Vector3.zero, Vector3.zero, Vector3.one);
            }
        }

        private int Compare(RuneData x, RuneData y)
        {
            ItemConfig xItemCfg = ConfigManager.Instance.GetTemplate<ItemConfig>(x.id);
            ItemConfig yItemCfg = ConfigManager.Instance.GetTemplate<ItemConfig>(y.id);
            if (xItemCfg.Type.CompareTo(yItemCfg.Type) != 0)
            {
                return xItemCfg.Type.CompareTo(yItemCfg.Type);
            }
            if (xItemCfg.ItemColor.CompareTo(yItemCfg.ItemColor) != 0)
            {
                return -xItemCfg.ItemColor.CompareTo(yItemCfg.ItemColor);
            }
            else if (x.lv.CompareTo(y.lv) != 0)
            {
                return -x.lv.CompareTo(y.lv);
            }
            else if (x.id.CompareTo(y.id) != 0)
            {
                return -x.id.CompareTo(y.id);
            }
            else return 1;
        }
    }
}