using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

using UnityEngine;
using UnityEngine.UI;
namespace vnxbqy.UI
{
    public class RuneResolveWin : Window
    {
        [SerializeField] Text m_ItemCount0;
        [SerializeField] Text m_ItemCount1;
        [SerializeField] Text m_ItemResolveCount0;
        [SerializeField] Text m_ItemResolveCount1;
        [SerializeField] Button m_Resolve;
        [SerializeField] ScrollerController m_Controller;
        [SerializeField] List<Button> m_CheckBtns;
        [SerializeField] Transform[] m_CheckSigns;
        [SerializeField] UIEffect m_FlutterEffect;
        [SerializeField] UIEffect m_AbsorbEffect;
        [SerializeField] Button m_JumpBtn0;
        [SerializeField] Button m_JumpBtn1;
        [SerializeField] RectTransform m_ContainerRuneSoul;
        [SerializeField] Text m_RuneSoulAdd;

        List<ushort> resolveItems { get { return runeResolveModel.resolveItems; } }
        List<Transform> resolveObjs { get { return runeResolveModel.resolveObjs; } }
        List<int> itemIndexs { get { return runeResolveModel.itemIndexs; } }
        Dictionary<int, bool> resolveSigns { get { return runeResolveModel.resolveSigns; } }

        bool doResolveItem = false;

        RuneModel model { get { return ModelCenter.Instance.GetModel<RuneModel>(); } }
        RuneResolveModel runeResolveModel { get { return ModelCenter.Instance.GetModel<RuneResolveModel>(); } }
        VirtualPackModel virtualPackModel { get { return ModelCenter.Instance.GetModel<VirtualPackModel>(); } }
        RuneComposeModel runeComposeModel { get { return ModelCenter.Instance.GetModel<RuneComposeModel>(); } }

        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
            m_Resolve.onClick.AddListener(OnResolve);
            for (int i = 0; i < m_CheckBtns.Count; i++)
            {
                int itemColor = i + 1;
                m_CheckBtns[i].onClick.AddListener(() =>
                {
                    OnClickCheck(itemColor);
                });
            }
            m_JumpBtn0.onClick.AddListener(OnJumpRuneTower);
            m_JumpBtn1.onClick.AddListener(OnJumpRuneTower);

            m_Controller.OnRefreshCell += OnRefreshCell;
        }

        protected override void OnPreOpen()
        {
            virtualPackModel.virtualPackRefresh += VirtualPackRefresh;
            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshInfoEvent;
            runeResolveModel.onResolveSelect += OnResolveSelect;

            doResolveItem = false;

            DisplayRuneItems();

            m_ContainerRuneSoul.SetActive(false);
        }

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

        protected override void OnPreClose()
        {
            doResolveItem = false;
            virtualPackModel.virtualPackRefresh -= VirtualPackRefresh;
            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshInfoEvent;
            runeResolveModel.onResolveSelect -= OnResolveSelect;

            StopAllCoroutines();
        }

        protected override void OnAfterClose()
        {

        }

        private void VirtualPackRefresh(PackType packType)
        {
            if (packType == PackType.RunePack)
            {
                DisplayRuneItems();
                RefreshResolveGetItems();
            }
        }

        private void OnResolve()
        {
            resolveItems.Clear();
            foreach (var key in resolveSigns.Keys)
            {
                if (resolveSigns[key]
                    && key < itemIndexs.Count)
                {
                    var index = itemIndexs[key];
                    RuneItem item;
                    if (virtualPackModel.TryGetItem(PackType.RunePack, index, out item))
                    {
                        resolveItems.Add((ushort)item.index);
                    }
                }
            }
            if (resolveItems.Count < 1)
            {
                ServerTipDetails.DisplayNormalTip(Language.Get("L1059"));
                return;
            }

            var page = Mathf.CeilToInt((float)resolveItems.Count / 50);
            doResolveItem = true;
            for (int i = 0; i < page; i++)
            {
                ushort[] resolves = resolveItems.Skip(i * 50).Take((i < page - 1) ? 50 : (resolveItems.Count - i * 50)).ToArray();
                var pak = new CA566_tagCMRuneDecompose();
                pak.QualityCnt = 0;
                pak.QualityList = new byte[0];
                pak.PlaceIndexList = resolves;
                pak.Count = (byte)resolves.Length;
                GameNetSystem.Instance.SendInfo(pak);
            }
        }

        void OnClickCheck(int itemColor)
        {
            bool check = runeResolveModel.IsQualitySign(itemColor);
            OnCheck(itemColor, !check);
        }

        private void OnCheck(int itemColor, bool check)
        {
            runeResolveModel.SetQualityMark(itemColor, check);

            var checkSign = GetCheckSign(itemColor);

            if (checkSign != null)
            {
                checkSign.SetActive(runeResolveModel.IsQualitySign(itemColor));
            }

            for (int i = 0; i < itemIndexs.Count; i++)
            {
                var index = itemIndexs[i];
                RuneItem item;
                if (virtualPackModel.TryGetItem(PackType.RunePack, index, out item))
                {
                    var config = ItemConfig.Get(item.id);
                    if (config.ItemColor == itemColor && config.Type == RuneModel.RUNE_TYPE)
                    {
                        resolveSigns[i] = check;
                    }
                }
            }

            m_Controller.m_Scorller.RefreshActiveCellViews();
            RefreshResolveGetItems();
        }

        void DisplayRuneItems()
        {
            if (resolveObjs.Count > 0 && doResolveItem)
            {
                var _time = 0.0f;
                for (int i = 0; i < resolveObjs.Count; i++)
                {
                    if (resolveObjs[i] != null)
                    {
                        resolveObjs[i].SetActive(false);
                        var _uieffect = EffectMgr.Instance.PlayUIEffect(1007, 2500, resolveObjs[i].parent, false);
                        _time = _uieffect != null ? _uieffect.duration : 0.0f;
                        _uieffect.target.transform.localPosition = resolveObjs[i].localPosition;
                    }
                }
                doResolveItem = false;
                StartCoroutine(Co_PlayEffect(_time));
            }
            else
            {
                DisplayResolveItems();
            }
        }

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

        void DisplayResolveItems()
        {
            resolveObjs.Clear();
            DisplayRunes();
            ResetResolveSelect();
        }

        void ResetResolveSelect()
        {
            resolveSigns.Clear();

            for (int i = 0; i < itemIndexs.Count; i++)
            {
                var index = itemIndexs[i];
                RuneItem item;
                if (virtualPackModel.TryGetItem(PackType.RunePack, index, out item))
                {
                    resolveSigns[i] = item.itemType == RuneModel.RUNE_CREAMTYPE;
                }
            }

            OnCheck(1, runeResolveModel.IsQualitySign(1));
            OnCheck(2, runeResolveModel.IsQualitySign(2));
            OnCheck(3, runeResolveModel.IsQualitySign(3));
            OnCheck(4, runeResolveModel.IsQualitySign(4));
        }

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

        void DisplayRunes()
        {
            m_Controller.Refresh();

            virtualPackModel.GetItemIndexs(PackType.RunePack, ref runeResolveModel.itemIndexs);
            itemIndexs.Sort(Compare);
            int _line = Mathf.CeilToInt((float)itemIndexs.Count / 4);
            for (int i = 0; i < _line; i++)
            {
                m_Controller.AddCell(ScrollerDataType.Normal, i);
            }

            m_Controller.Restart();
        }

        void RefreshResolveGetItems()
        {
            float _itemCnt = 0;
            float _magicCnt = 0;
            float _soulCnt = 0;
            foreach (int key in resolveSigns.Keys)
            {
                if (!resolveSigns[key])
                {
                    continue;
                }

                if (key < itemIndexs.Count)
                {
                    var index = itemIndexs[key];
                    RuneItem item;
                    if (virtualPackModel.TryGetItem(PackType.RunePack, index, out item))
                    {
                        _itemCnt += runeResolveModel.GetRuneResolveGetSplinters(item.id, item.level);
                        _soulCnt += runeResolveModel.GetRuneResolveGetSouls(item.id);
                        if (model.IsMultiPropertyRune(item.id)
                            && runeResolveModel.IsComposeSource(item.sourceType))
                        {
                            var composeConfig = RuneComposeConfig.Get(item.id);
                            _magicCnt += (composeConfig == null ? 0 : composeConfig.NeedMJ);
                        }
                    }
                }
            }
            m_ItemCount1.text = UIHelper.ReplaceLargeNum(PlayerDatas.Instance.GetPlayerDataByType(PlayerDataType.RuneSplinters));
            m_ItemCount0.text = UIHelper.ReplaceLargeNum(PlayerDatas.Instance.GetPlayerDataByType(PlayerDataType.MagicEssence));
            m_ItemResolveCount1.SetActive(_itemCnt != 0);
            m_ItemResolveCount0.SetActive(_magicCnt != 0);
            m_ItemResolveCount0.text = StringUtility.Contact("+", UIHelper.ReplaceLargeNum(_magicCnt));
            m_ItemResolveCount1.text = StringUtility.Contact("+", UIHelper.ReplaceLargeNum((int)_itemCnt));
            m_RuneSoulAdd.text = Language.Get("RuneSoul", UIHelper.ReplaceLargeNum((int)_soulCnt));
        }

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

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

        private void PlayerDataRefreshInfoEvent(PlayerDataType type)
        {
            if (type == PlayerDataType.MagicEssence
                || type == PlayerDataType.RuneSplinters)
            {
                RefreshResolveGetItems();
            }
        }

        private void OnResolveSelect(int line)
        {
            m_Controller.RefreshSingleCellView(line);
            RefreshResolveGetItems();
        }

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

        Transform GetCheckSign(int itemColor)
        {
            switch (itemColor)
            {
                case 1:
                    return m_CheckSigns.Length > 0 ? m_CheckSigns[0] : null;
                case 2:
                    return m_CheckSigns.Length > 1 ? m_CheckSigns[1] : null;
                case 3:
                    return m_CheckSigns.Length > 2 ? m_CheckSigns[2] : null;
                case 4:
                    return m_CheckSigns.Length > 3 ? m_CheckSigns[3] : null;
            }
            return null;
        }

        int Compare(int lhs, int rhs)
        {
            RuneItem lhsItem = null;
            RuneItem rhsItem = null;
            if (virtualPackModel.TryGetItem(PackType.RunePack, lhs, out lhsItem)
                && virtualPackModel.TryGetItem(PackType.RunePack, rhs, out rhsItem))
            {
                var lhsConfig = ItemConfig.Get(lhsItem.id);
                var rhsConfig = ItemConfig.Get(rhsItem.id);
                if (lhsConfig.Type != rhsConfig.Type)
                {
                    return lhsConfig.Type.CompareTo(rhsConfig.Type);
                }
                if (lhsConfig.ItemColor != rhsConfig.ItemColor)
                {
                    return -lhsConfig.ItemColor.CompareTo(rhsConfig.ItemColor);
                }
                if (lhsItem.level != rhsItem.level)
                {
                    return -lhsItem.level.CompareTo(rhsItem.level);
                }
                if (lhsItem.id != rhsItem.id)
                {
                    return -lhsItem.id.CompareTo(rhsItem.id);
                }
            }
            return 1;
        }
    }
}