using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using TableConfig;
using System;
using System.Linq;
using Snxxz.UI;

public class WingsRefined : MonoBehaviour
{
    //羽翼精炼
    public int LINE = 6;//需要生成的行数
    [SerializeField] ScrollerController m_ScrollerController;
    [SerializeField] Image WingsBG;//背景框
    [SerializeField] Button WingsImage;//（没有翅膀按钮点击）
    [SerializeField] Button IconButton;//有翅膀按钮和图
    [SerializeField] Text WText;//翅膀资质
    [SerializeField] GameObject EquipFirstTxt;//没有翅膀提示框
    [SerializeField] Text PlusNum;//预览比值1
    [SerializeField] Text PlusNum1;//预览比值2
    [SerializeField] Text PlusNum2;//预览比值3
    [SerializeField] GameObject FullTxt;//满级显示提示本文
    [SerializeField] Button _refiningBtn;//精炼按钮
    [SerializeField] Button _KeyRefiningBtn;//一键精炼按钮；
    [SerializeField] Button _RefineStopBtn;//停止精炼按钮
    [SerializeField] GameObject _ManagementFrame;//羽翼精炼面板框
    [SerializeField] RawImage _wingRawImage;//翅膀模型创建
    [SerializeField] Text _AttrNameTextNum1;//增加的伤害值
    [SerializeField] Text _AttrNameTextNum2;//增加的生命值
    [SerializeField] Slider _Pmgressbar;//精炼值
    [SerializeField] Text _PmgressText;//精炼数值
    [SerializeField] UIEffect m_UIEffect1;//翅膀特效1
    [SerializeField] UIEffect m_UIEffect2;//翅膀特效2
    public Vector3 Vec = new Vector3(0f, 90f, -60f);
    private Dictionary<int, int> _wingItemDic = new Dictionary<int, int>();//获取翅膀字典
    private Dictionary<int, bool> _DevourDIc = new Dictionary<int, bool>();//需要吞噬的物品
    private Dictionary<int, ItemModel> WingDic = new Dictionary<int, ItemModel>();//获取翅膀属性
    private List<int> intPetAbsorbTyp = new List<int>();
    Dictionary<int, WingRefineAttrModel> _DicWingRe = new Dictionary<int, WingRefineAttrModel>();//获取属性上限值

    ItemTipsModel _itemTipsModel;
    ItemTipsModel itemTipsModel { get { return _itemTipsModel ?? (_itemTipsModel = ModelCenter.Instance.GetModel<ItemTipsModel>()); } }

    PackModelInterface _modelInterface;
    PackModelInterface modelInterface { get { return _modelInterface ?? (_modelInterface = ModelCenter.Instance.GetModel<PackModelInterface>()); } }

    PlayerPackModel _playerPack;
    PlayerPackModel playerPack { get { return _playerPack ?? (_playerPack = ModelCenter.Instance.GetModel<PlayerPackModel>()); } }

    WingsRedDot M_WingsRedDotModel;
    WingsRedDot wingsRedDotModel { get { return M_WingsRedDotModel ?? (M_WingsRedDotModel = ModelCenter.Instance.GetModel<WingsRedDot>()); } }

    private bool IsOpen = false;
    class WingRefineAttrModel
    {
        public int Ability1;//属性值1
        public int Ability1Value;//数值1
        public int Ability2;//属性值2
        public int Ability2Value;//数值2
    }

    public class EquippedClass
    {
        public int ItemId;//物品ID
        public string Index;//索引下标
        public int BackpackIndex;//所对应背包的索引
    }



    private int _currentRefining = 0;//当前精炼度
    private int _currentRefiningAll = 1;//总精炼度
    private float _RefiningRatio;//精炼比值

    private int Lifevalue = 0;//生命值
    private float Damagevalue = 0;//伤害值
    private bool AutomaticBool = false;//自动精炼
    private bool CoroutinesBool = true;//协程控制

    public Dictionary<int, int> wingLv2GenerDict = new Dictionary<int, int>();

    private void Awake()
    {
        var _funcCfg = Config.Instance.Get<FuncConfigConfig>("WingLV");
        LitJson.JsonData _json = LitJson.JsonMapper.ToObject(_funcCfg.Numerical1);
        foreach (var _wingLv in _json.Keys)
        {
            wingLv2GenerDict.Add(int.Parse(_wingLv), int.Parse(_json[_wingLv].ToString()));
        }
        WingRefine();
    }

    void OnEnable()
    {
        wingsRedDotModel.IsBoolOpenWingeWin = true;
        AutomaticBool = false;
        CoroutinesBool = true;
        IsOpen = false;
        _wingRawImage.gameObject.SetActive(false);
        _DevourDIc.Clear();
        m_ScrollerController.OnRefreshCell += OnRefreshGridCell;

        playerPack.RefreshPackAct += ItemsToRefresh;//背包物品刷新
        playerPack.ItemCntReduceAct += BackpackRefresh;//背包物品清理
        playerPack.ItemCntAddAct += EquippedWithRefresh;//角色装备刷新

        EquipmentPositionJudgment();//判断是否有穿戴翅膀
        WingClassify();
        SortAll();
        _RefineStopBtn.gameObject.SetActive(false);
        _KeyRefiningBtn.gameObject.SetActive(true);
        _refiningBtn.gameObject.SetActive(true);
        OnCreateGridLineCell(m_ScrollerController);
        PreviewTheValue();
    }


    void Start()
    {
        WingsImage.onClick.AddListener(WingsBGButton);
        _refiningBtn.onClick.AddListener(RefiningButton);
        _KeyRefiningBtn.onClick.AddListener(KeyRefiningButton);
        _RefineStopBtn.onClick.AddListener(RefineStopButton);
    }

    void OnDisable()
    {
        wingsRedDotModel.IsBoolOpenWingeWin = false;
        IsOpen = false;
        _DevourDIc.Clear();
      //  _wingItemDic.Clear();
        PlusNum.gameObject.SetActive(false);
        PlusNum1.gameObject.SetActive(false);
        PlusNum2.gameObject.SetActive(false);
        StopCoroutine("AkeyRefining");
        UI3DModelExhibition.Instance.StopShowWing();
        // RoleCameraCtrl.GetInstance().OnDestroyModel();
        playerPack.RefreshPackAct -= ItemsToRefresh;//背包物品刷新
        playerPack.ItemCntReduceAct -= BackpackRefresh;//背包物品清理
        playerPack.ItemCntAddAct -= EquippedWithRefresh;//角色装备刷新
        m_ScrollerController.OnRefreshCell -= OnRefreshGridCell;
    }
    private void OnCreateGridLineCell(ScrollerController gridCtrl)
    {
        gridCtrl.Refresh();
        int code = 0;
        for (code = 0; code < LINE; code++)
        {
            gridCtrl.AddCell(ScrollerDataType.Header, code);
        }
        gridCtrl.Restart();
    }

    private void OnRefreshGridCell(ScrollerDataType type, CellView cell)
    {
        int gridlineIndex = cell.index;
        int childCode = 0;
        for (childCode = 0; childCode < cell.transform.childCount; childCode++)
        {
            ChildNodes _ChildNodes = cell.transform.GetChild(childCode).GetComponent<ChildNodes>();
            _ChildNodes._ItemIcon.SetActive(false);
            _ChildNodes._Elect.SetActive(false);
            int cellCount = (cell.transform.childCount) * gridlineIndex + (childCode + 1);
            if (cellCount - 1 < intPetAbsorbTyp.Count)
            {
                int _index = cellCount - 1;
                _ChildNodes._ItemIcon.SetActive(true);
                ItemModel model = playerPack.GetItemModelByIndex(PackType.rptItem, intPetAbsorbTyp[cellCount - 1]);
                _ChildNodes._ItemIcon.GetComponent<ItemCell>().Init(model);
                _ChildNodes._ItemButton.OnOneParaClick = null;
                if (_DevourDIc.ContainsKey(intPetAbsorbTyp[cellCount - 1]))
                {
                    _ChildNodes._Elect.SetActive(true);

                }

                _ChildNodes._ItemButton.OnOneParaClick = (int info) =>
                {
                    if (_ChildNodes._Elect.activeSelf)
                    {
                        _ChildNodes._Elect.SetActive(false);
                        _DevourDIc.Remove(intPetAbsorbTyp[_index]);
                    }
                    else
                    {
                        if (IsAbsorb())
                        {
                            _ChildNodes._Elect.SetActive(true);
                            _DevourDIc.Add(intPetAbsorbTyp[_index], true);
                        }
                        else
                        {

                            SysNotifyMgr.Instance.ShowTip("WingRefineisFull");
                        }
                    }
                    m_ScrollerController.m_Scorller.RefreshActiveCellViews();//刷新可见
                    PreviewTheValue();
                };
            }
        }
    }

    bool IsAbsorb()//判断能否吸收
    {
        int expValue = 0;
        expValue += (int)_currentRefining;
        if (_DevourDIc.Count != 0)
        {
            foreach (var key in _DevourDIc.Keys)
            {
                expValue+= Sort2(key);
                //ItemModel model = playerPack.GetItemModelByIndex(PackType.rptItem, key);
                //expValue += Config.Instance.Get<WingRefineExpConfig>(model.itemInfo.ItemID).EXPupper;
            }
        }
        return _currentRefiningAll > expValue;
    }

    void RefineStopButton()//停止精炼
    {
        _RefineStopBtn.gameObject.SetActive(false);
        _KeyRefiningBtn.gameObject.SetActive(true);
        _refiningBtn.gameObject.SetActive(true);
        StopCoroutine("AkeyRefining");
    }

    void RefiningButton()//精炼按钮
    {
        ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip, (int)RoleEquipType.retWing);

        if (itemModel == null)
        {
            MessageWin.Inst.ShowFixedTip(Language.Get("EquipReinforceWin_WingRefLv_2"));
            return;
        }

        if (_DevourDIc.Count == 0)
        {
            if (!JudgeConditions())
            {
                MessageWin.Inst.ShowFixedTip(Language.Get("Z1018"));//翅膀精炼已到达满级无法继续精炼
            }
            else
            {
                MessageWin.Inst.ShowFixedTip(Language.Get("EquipReinforceWin_WingHText_1"));//所需材料不足
            }

            return;
        }
        if (JudgeConditions())
        {
            CA32E_tagCMWingUp _CA32E = new CA32E_tagCMWingUp();
            byte[] _byte = new byte[1];
            _byte[0] = (byte)_DevourDIc.Keys.First();
            _CA32E.Count = (byte)_byte.Length;
            _CA32E.WingIndexList = _byte;
            GameNetSystem.Instance.SendInfo(_CA32E);
        }
        else
        {
            MessageWin.Inst.ShowFixedTip(Language.Get("Z1018"));//翅膀精炼已到达满级无法继续精炼
        }
    }


    void PreviewTheValue()//预览值
    {
        if (_DevourDIc.Count == 0)
        {
            PlusNum.gameObject.SetActive(false);
            PlusNum1.gameObject.SetActive(false);
            PlusNum2.gameObject.SetActive(false);
        }
        else
        {
            PlusNum.gameObject.SetActive(true);
            PlusNum1.gameObject.SetActive(true);
            PlusNum2.gameObject.SetActive(true);
        }


        ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip, (int)RoleEquipType.retWing);
        if (itemModel == null)
            return;

        int YRefiningRatioMin = 0;//预览生命比值
        int YRefiningRatioMax = 0;//预览生命比值
        float _RefiningDegreesMin = 0;
        float _RefiningDegreesMaX = 0;
        int Min = 0;
        int Max = 0;

        foreach (var key in _DevourDIc.Keys)
        {
            var wingConfig = Config.Instance.Get<WingRefineExpConfig>(_wingItemDic[key]);
            if (WingDic[key].GetUseDataModel((int)ItemUseDataKey.Def_IudetWingProgressValue) != null || WingDic[key].GetUseDataModel((int)ItemUseDataKey.Def_IudetWingMaterialItemID) != null)
            {

                Min += wingConfig.EXPlower + GetWingRefiningValue(WingDic[key]); ;
                Max += wingConfig.EXPupper + GetWingRefiningValue(WingDic[key]); ;
            }
            else
            {
                ItemModel model = playerPack.GetItemModelByIndex(PackType.rptItem, key);

                for (int i = 0; i < model.itemInfo.ItemCount; i++)
                {
                    if (wingConfig.EXPmaterial != null && !wingConfig.EXPmaterial.Equals(string.Empty))
                    {
                        Dictionary<int, int> dicExp = ConfigParse.GetDic<int, int>(wingConfig.EXPmaterial);
                        Min += dicExp[itemModel.chinItemModel.LV];
                        Max += dicExp[itemModel.chinItemModel.LV];
                    }
                    else
                    {
                        Min += wingConfig.EXPlower;
                        Max += wingConfig.EXPupper;
                    }
                }
            }
        }

        int PreviewMin = _currentRefining + Min;//最大下限
        int PreviewMax = _currentRefining + Max;//最大上限值
        if (PreviewMin >= _currentRefiningAll)
        {
            PreviewMin = _currentRefiningAll;
        }
        if (PreviewMax >= _currentRefiningAll)
        {
            PreviewMax = _currentRefiningAll;
        }
        var config = Config.Instance.Get<WingRefineExpConfig>((int)itemModel.itemInfo.ItemID);
        _RefiningDegreesMin = (float)Math.Round((itemModel.chinItemModel.EffectValueA2 +
            _DicWingRe[config.WingsPhase].Ability2Value *
            ((float)PreviewMin / _currentRefiningAll)) / 100, 2);

        _RefiningDegreesMaX = (float)Math.Round((itemModel.chinItemModel.EffectValueA2 +
                 _DicWingRe[config.WingsPhase].Ability2Value *
                 ((float)PreviewMax / _currentRefiningAll)) / 100, 2);

        YRefiningRatioMin = (Mathf.CeilToInt(_DicWingRe[config.WingsPhase]
            .Ability1Value * ((float)PreviewMin / _currentRefiningAll) + itemModel.chinItemModel.EffectValueA1));
        YRefiningRatioMax = (Mathf.CeilToInt(_DicWingRe[config.WingsPhase]
            .Ability1Value * ((float)PreviewMax / _currentRefiningAll) + itemModel.chinItemModel.EffectValueA1));

        PlusNum1.text = "+" + ((float)Math.Round(_RefiningDegreesMin - Damagevalue, 1)).ToString("f2") + "% ~ " + ((float)Math.Round(_RefiningDegreesMaX - Damagevalue, 1)).ToString("f2") + "%";
        PlusNum2.text = "+" + (YRefiningRatioMin - Lifevalue) + " ~ " + (YRefiningRatioMax - Lifevalue);
        PlusNum.text = "+" + Min.ToString() + " ~ " + Max.ToString();
    }

    bool JudgeConditions()//执行判断条件
    {

        if (_currentRefiningAll > _currentRefining)
        {
            return true;
        }
        else
        {
            return false;
        }

    }
    Dictionary<int, int> dicWingUseDateValue = new Dictionary<int, int>();
    private int GetWingRefiningValue(ItemModel ItemModel)
    {
        dicWingUseDateValue.Clear();
        int GetUseDateValue = 0;
        if (ItemModel.GetUseDataModel((int)ItemUseDataKey.Def_IudetWingMaterialItemID) != null
            || ItemModel.GetUseDataModel((int)ItemUseDataKey.Def_IudetWingMaterialItemCount) != null)
        {
            for (int i = 0; i < ItemModel.GetUseDataModel((int)ItemUseDataKey.Def_IudetWingMaterialItemID).Count; i++)
            {
                dicWingUseDateValue.Add(ItemModel.GetUseDataModel((int)ItemUseDataKey.Def_IudetWingMaterialItemID)[i], ItemModel.GetUseDataModel((int)ItemUseDataKey.Def_IudetWingMaterialItemCount)[i]);
            }
        }
        if (ItemModel.GetUseDataModel((int)ItemUseDataKey.Def_IudetWingProgressValue) != null)
        {
            GetUseDateValue += ItemModel.GetUseDataModel((int)ItemUseDataKey.Def_IudetWingProgressValue)[0];
        }
        int WingLv1 = ItemModel.chinItemModel.LV;
        foreach (var key in dicWingUseDateValue.Keys)
        {
            var wingConfig = Config.Instance.Get<WingRefineExpConfig>(key);
            if (wingConfig.EXPmaterial != null && !wingConfig.EXPmaterial.Equals(string.Empty))
            {
                Dictionary<int, int> dicExp = ConfigParse.GetDic<int, int>(wingConfig.EXPmaterial);
                GetUseDateValue -= dicExp[WingLv1] * dicWingUseDateValue[key];
            }

        }
        ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip, (int)RoleEquipType.retWing);
        int WingLv2 = itemModel.chinItemModel.LV;
        foreach (var key in dicWingUseDateValue.Keys)
        {
            var wingConfig = Config.Instance.Get<WingRefineExpConfig>(key);
            if (wingConfig.EXPmaterial != null && !wingConfig.EXPmaterial.Equals(string.Empty))
            {
                Dictionary<int, int> dicExp = ConfigParse.GetDic<int, int>(wingConfig.EXPmaterial);
                GetUseDateValue += dicExp[WingLv2] * dicWingUseDateValue[key];
            }
        }
        return GetUseDateValue;
    }

    void KeyRefiningButton()//一键精炼
    {
        ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip, (int)RoleEquipType.retWing);
        if (itemModel == null)
        {
            MessageWin.Inst.ShowFixedTip(Language.Get("EquipReinforceWin_WingRefLv_2"));
            return;
        }

        if (_DevourDIc.Count > 0 && JudgeConditions())
        {
            AutomaticBool = true;
            StartCoroutine("AkeyRefining");
        }
        else
        {
            if (!JudgeConditions())
            {
                MessageWin.Inst.ShowFixedTip(Language.Get("Z1018"));//翅膀精炼已到达满级无法继续精炼
            }
            else if (_DevourDIc.Count <= 0)
            {
                MessageWin.Inst.ShowFixedTip(Language.Get("EquipReinforceWin_WingHText_1"));//所需材料不足
            }

        }

    }
    IEnumerator AkeyRefining()//一键精炼协成
    {
        while (true)
        {
            if (JudgeConditions() && _DevourDIc.Count > 0)
            {
                if (CoroutinesBool)
                {
                    _RefineStopBtn.gameObject.SetActive(true);
                    _KeyRefiningBtn.gameObject.SetActive(false);
                    _refiningBtn.gameObject.SetActive(false);
                    CA32E_tagCMWingUp _CA32E = new CA32E_tagCMWingUp();
                    byte[] _byte = new byte[1];
                    _byte[0] = (byte)_DevourDIc.Keys.First();
                    _CA32E.Count = (byte)_byte.Length;
                    _CA32E.WingIndexList = _byte;
                    GameNetSystem.Instance.SendInfo(_CA32E);
                    CoroutinesBool = false;
                    yield return null;
                }
            }
            if (!JudgeConditions())
            {
                RefineStopButton();//停止精炼按钮
                MessageWin.Inst.ShowFixedTip(Language.Get("Z1018"));//翅膀精炼已到达满级无法继续精炼
                yield break;
            }
            if (_DevourDIc.Count <= 0)
            {
                RefineStopButton();//停止精炼按钮
                yield break;
            }
            yield return null;
        }
    }
    void WingsBGButton()//点击翅膀背景框按钮
    {

        bool markingbbol = false;
        SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.rptItem);
        if (singlePack == null || singlePack.GetPackModelIndexDict().Count == 0)
        {
            MessageWin.Inst.ShowFixedTip(Language.Get("WingsRefine_NoWing"));
            return;
        }
        Dictionary<int, ItemModel> backpack_dic = singlePack.GetPackModelIndexDict();
        foreach (int index in backpack_dic.Keys)
        {
            int _id = (int)backpack_dic[index].itemInfo.ItemID;
            if (!ItemConfig.tag_Wings.ContainsKey(_id))
            {
                continue;
            }

            if (ItemConfig.tag_Wings[_id].Type == 111 &&
                int.Parse(ItemConfig.tag_Wings[_id].JobLimit.ToString().Substring(0, 1)) == PlayerDatas.Instance.baseData.Job)
            {
                markingbbol = true;
            }

        }
        if (markingbbol)
        {
            WindowCenter.Instance.Open<WingsBouncedWin>();
        }
        else
        {
            MessageWin.Inst.ShowFixedTip(Language.Get("WingsRefine_NoWing"));
        }

    }

    void Backpacking()//物品读取
    {
        _wingItemDic.Clear();
        intPetAbsorbTyp.Clear();
        WingDic.Clear();
        //背包字典

        SinglePackModel rptItemPack = playerPack.GetSinglePackModel(PackType.rptItem);
        ItemModel putOnModel = playerPack.GetItemModelByIndex(PackType.rptEquip, (int)RoleEquipType.retWing);
        if (rptItemPack == null || rptItemPack.GetPackModelIndexDict().Count == 0 || putOnModel == null)
        {
            return;
        }
        int itemID = putOnModel.itemInfo.ItemID;//物品ID
        var WingItem = Config.Instance.Get<WingRefineExpConfig>(itemID);
        if (WingItem == null)
        {
            return;
        }
        Dictionary<int, ItemModel> backpack_Dic = rptItemPack.GetPackModelIndexDict();

        foreach (int itemIndex in backpack_Dic.Keys)
        {
            var WingItem1 = Config.Instance.Get<WingRefineExpConfig>((int)backpack_Dic[itemIndex].itemInfo.ItemID);
            if (ItemConfig.tag_Wings.ContainsKey((int)backpack_Dic[itemIndex].itemInfo.ItemID) && WingItem1 != null)
            {
                _wingItemDic.Add(itemIndex, (int)backpack_Dic[itemIndex].itemInfo.ItemID);
                WingDic.Add(itemIndex, backpack_Dic[itemIndex]);
            }

        }
        if (_wingItemDic.Count != 0)
        {
            foreach (var key in _wingItemDic.Keys)
            {
                intPetAbsorbTyp.Add(key);
            }
        }
    }

    void EquipmentPositionJudgment()//判断是否有穿戴翅膀
    {
        Backpacking();//物品读取
        ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip, (int)RoleEquipType.retWing);
        int itemID = 0;
        if (itemModel != null)
        {
            itemID = itemModel.itemInfo.ItemID;//物品ID
        }
        var WingItem = Config.Instance.Get<WingRefineExpConfig>(itemID);
        if (itemModel != null && WingItem != null)
        {
            WingsImage.gameObject.SetActive(false);
            IconButton.gameObject.SetActive(true);
            WingsBG.SetItemBackGround(modelInterface.GetItemQuality(itemModel.itemInfo.ItemID, itemModel.useDataDict));
            IconButton.GetComponent<Image>().SetSprite(itemModel.chinItemModel.IconKey);
            IconButton.RemoveAllListeners();
            IconButton.AddListener(() =>
            {
                itemTipsModel.SetItemTipsModel(PackType.rptEquip, itemModel.itemInfo.ItemGUID);
            });
            ModelCreationDisplay();//模型展示创建
            RefiningDegrees();//精炼度（刷新）
        }
        else
        {
            EquipFirstTxt.SetActive(true);
            _wingRawImage.gameObject.SetActive(false);
            WingsImage.gameObject.SetActive(true);
            IconButton.gameObject.SetActive(false);
            WingsBG.SetItemBackGround(1);//翅膀框默认颜色值
            DegreeOfRefining();//精炼度初始没翅膀时
        }
    }

    void ModelCreationDisplay()//模型展示创建
    {
        if (_wingRawImage.gameObject.activeSelf)
        {
            return;
        }
        EquipFirstTxt.SetActive(false);
        ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip, (int)RoleEquipType.retWing);
        _wingRawImage.gameObject.SetActive(true);
        var config = Config.Instance.Get<WingRefineExpConfig>((int)itemModel.itemInfo.ItemID);
        int _modelID = config.Model;
        UI3DModelExhibition.Instance.BeginShowWing(_modelID, Vec, _wingRawImage);
    }



    void DegreeOfRefining()//精炼度初始没翅膀时
    {
        WText.gameObject.SetActive(true);
        _AttrNameTextNum1.text = "0.00%";
        Damagevalue = 0;
        Lifevalue = 0;
        _AttrNameTextNum2.text = "0";
        _Pmgressbar.value = 0f;
        _PmgressText.text = "0/0";
        WText.text = Language.Get("EquipReinforceWin_WingRefLv_2");
    }

    void RefiningDegrees()//精炼度（刷新）
    {
        WText.gameObject.SetActive(true);

        ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip, (int)RoleEquipType.retWing);

        if (itemModel.GetUseDataModel((int)ItemUseDataKey.Def_IudetWingProgressValue) != null)
        {
            _currentRefining = itemModel.GetUseDataModel((int)ItemUseDataKey.Def_IudetWingProgressValue)[0];//当前精炼度
        }
        else
        {
            _currentRefining = 0;//当前精炼度
        }
        var wingRefineAttrConfigs = Config.Instance.GetAllValues<WingRefineAttrConfig>();
        foreach (var config in wingRefineAttrConfigs)
        {
            if (itemModel.chinItemModel.LV == config.wingsPhase)
            {
                _currentRefiningAll = config.EXPupper;//总精炼度
                _PmgressText.text = _currentRefining.ToString() + "/" + _currentRefiningAll.ToString();
                if (_currentRefining >= _currentRefiningAll)
                {
                    _currentRefining = _currentRefiningAll;
                    FullTxt.SetActive(true);
                }
                else
                {
                    FullTxt.SetActive(false);
                }
                if (IsOpen)
                {
                    EffectMgr.Instance.PlayUIEffect(1070, 2500, m_UIEffect1.transform, false);
                }

                if (_currentRefining >= _currentRefiningAll && IsOpen)
                {
                    m_UIEffect2.Play();
                }
                if (!IsOpen)
                {
                    IsOpen = true;
                }
                _Pmgressbar.value = (float)_currentRefining / _currentRefiningAll;
                _RefiningRatio = (float)_currentRefining / _currentRefiningAll;//精炼比值
                int Number = Mathf.CeilToInt(((float)_currentRefining / _currentRefiningAll) * 100);
                WText.text = string.Format(Language.Get("EquipReinforceWin_WingRefLv_1"), Number) + "%";
                float _RefiningDegrees = (float)Math.Round((double)(itemModel.chinItemModel.EffectValueA2 + _DicWingRe[itemModel.chinItemModel.LV].Ability2Value * _RefiningRatio) / 100, 1);
                _AttrNameTextNum1.text = _RefiningDegrees.ToString("f2") + "%";
                Damagevalue = _RefiningDegrees;
                _AttrNameTextNum2.text = (Mathf.CeilToInt(_DicWingRe[itemModel.chinItemModel.LV].Ability1Value * _RefiningRatio + itemModel.chinItemModel.EffectValueA1)).ToString();
                Lifevalue = Mathf.CeilToInt(_DicWingRe[itemModel.chinItemModel.LV].Ability1Value * _RefiningRatio + itemModel.chinItemModel.EffectValueA1);
            }
        }


    }
    void ItemSX(int _Equipped)//用于精炼度和边框变色的刷新
    {
        if (_Equipped == (int)RoleEquipType.retWing)
        {

            ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip, (int)RoleEquipType.retWing);
            ;
            int ItemColor = modelInterface.GetItemQuality(itemModel.itemInfo.ItemID, itemModel.useDataDict);
            WingsBG.SetItemBackGround(ItemColor);
            IconButton.GetComponent<Image>().SetSprite(itemModel.chinItemModel.IconKey);
            int Number = Mathf.CeilToInt(((float)_currentRefining / _currentRefiningAll) * 100);
            WText.text = string.Format(Language.Get("EquipReinforceWin_WingRefLv_1"), Number) + "%";
        }
    }

    void WingRefine()//精炼属性值获取
    {
        var wingConfigs = Config.Instance.GetAllValues<WingRefineAttrConfig>();
        foreach (var config in wingConfigs)
        {
            if (!_DicWingRe.ContainsKey(config.wingsPhase))
            {
                WingRefineAttrModel _wingRefineAttrModel = new WingRefineAttrModel();
                int[] array = ConfigParse.GetKeyValueKeys<int>(config.attrupper);
                int[] intarray = ConfigParse.GetKeyValueValues<int>(config.attrupper);
                _wingRefineAttrModel.Ability1 = array[0];
                _wingRefineAttrModel.Ability2 = array[1];
                _wingRefineAttrModel.Ability1Value = intarray[0];
                _wingRefineAttrModel.Ability2Value = intarray[1];
                _DicWingRe.Add(config.wingsPhase, _wingRefineAttrModel);
            }
        }
    }



    void ItemsToRefresh(PackType type)//背包刷新
    {
        Backpacking();
        if (AutomaticBool)
        {
            CoroutinesBool = true;
        }

        m_ScrollerController.m_Scorller.RefreshActiveCellViews();//刷新可见

    }

    void BackpackRefresh(PackType type, int itemPlace, int id)//背包物品清理
    {
        if (_DevourDIc.ContainsKey(itemPlace))
        {
            ItemModel model = playerPack.GetItemModelByIndex(PackType.rptItem, itemPlace);
            if (model == null)
            {
                _DevourDIc.Remove(itemPlace);
            }
        }

        Backpacking();
        if (AutomaticBool)
        {
            CoroutinesBool = true;
        }

        m_ScrollerController.m_Scorller.RefreshActiveCellViews();//刷新可见
        PreviewTheValue();
    }

    void EquippedWithRefresh(PackType type, int index, int id)//角色装备刷新
    {
        //临时条件判断
        if (type != PackType.rptEquip)
        {
            return;
        }


        if (index == (int)RoleEquipType.retWing)
        {
            WingsImage.gameObject.SetActive(false);
            IconButton.gameObject.SetActive(true);
            ModelCreationDisplay();
            ItemSX(index);
            RefiningDegrees();//精炼度（刷新）
        }

    }


    private int GetMaxOrderWing()
    {
        int MaxMaxOrder = 0;

        ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip, (int)RoleEquipType.retWing);
        if (itemModel != null)
        {
            WingRefineExpConfig wingRefineExpConfig = Config.Instance.Get<WingRefineExpConfig>(itemModel.itemInfo.ItemID);
            if (wingRefineExpConfig != null)
            {
                if (wingLv2GenerDict.ContainsKey(wingRefineExpConfig.WingsPhase) && wingLv2GenerDict[wingRefineExpConfig.WingsPhase] > MaxMaxOrder)
                {
                    MaxMaxOrder = wingLv2GenerDict[wingRefineExpConfig.WingsPhase];
                }

            }
        }

        if (intPetAbsorbTyp.Count > 0)
        {
            for (int i = 0; i < intPetAbsorbTyp.Count; i++)
            {
                ItemModel model = playerPack.GetItemModelByIndex(PackType.rptItem, intPetAbsorbTyp[i]);
                WingRefineExpConfig wingRefineExpConfig = Config.Instance.Get<WingRefineExpConfig>(model.itemInfo.ItemID);
                if (wingRefineExpConfig != null)
                {
                    if (wingLv2GenerDict.ContainsKey(wingRefineExpConfig.WingsPhase) && wingLv2GenerDict[wingRefineExpConfig.WingsPhase] > MaxMaxOrder)
                    {
                        MaxMaxOrder = wingLv2GenerDict[wingRefineExpConfig.WingsPhase];
                    }
                   
                }
            }

        }

        return MaxMaxOrder;
    }
    List<int> ClassifyList = new List<int>();//存背包位置
    private void WingClassify()
    {
        ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip, (int)RoleEquipType.retWing);
        if (itemModel == null)
        {
            return;
        }
        int MaxMaxOrder = GetMaxOrderWing();
        ClassifyList.Clear();
        if (MaxMaxOrder <= 2)//最高阶的翅膀或翅膀材料阶数为1阶或者2阶
        {
            for (int i = 0; i < intPetAbsorbTyp.Count; i++)
            {
                ItemModel model = playerPack.GetItemModelByIndex(PackType.rptItem, intPetAbsorbTyp[i]);
                WingRefineExpConfig wingRefineExpConfig = Config.Instance.Get<WingRefineExpConfig>(model.itemInfo.ItemID);
                if (wingRefineExpConfig.WingsPhase <= 0 || (wingLv2GenerDict.ContainsKey(wingRefineExpConfig.WingsPhase) && wingLv2GenerDict[wingRefineExpConfig.WingsPhase] <= 1))
                {
                    ClassifyList.Add(intPetAbsorbTyp[i]);
                }              
            }
        }
        else//最高阶的翅膀或翅膀材料阶数3阶及以上
        {
            for (int i = 0; i < intPetAbsorbTyp.Count; i++)
            {
                ItemModel model = playerPack.GetItemModelByIndex(PackType.rptItem, intPetAbsorbTyp[i]);
                WingRefineExpConfig wingRefineExpConfig = Config.Instance.Get<WingRefineExpConfig>(model.itemInfo.ItemID);
                if (wingRefineExpConfig.WingsPhase <= 0 || (wingLv2GenerDict.ContainsKey(wingRefineExpConfig.WingsPhase) && wingLv2GenerDict[wingRefineExpConfig.WingsPhase] <= MaxMaxOrder - 2))
                {
                    ClassifyList.Add(intPetAbsorbTyp[i]);
                }
            }
        }
        ClassifyList.Sort(Compare);    
        for (int j = 0; j < ClassifyList.Count; j++)
        {
            if (IsAbsorb())
            {
                _DevourDIc.Add(ClassifyList[j], true);
            }
        }
    }
    int Compare(int x, int y)//数组排列
    {
        bool havex = Sort1(x);
        bool havey = Sort1(y);
        if (havex.CompareTo(havey) != 0)
        {
            return -havex.CompareTo(havey);
        }
        var _sort_x = Sort2(x);
        var _sort_y = Sort2(y);
        return  -_sort_x.CompareTo(_sort_y);
    }

    private bool Sort1(int Index)
    {
        ItemModel model = playerPack.GetItemModelByIndex(PackType.rptItem, Index);
        if (model.itemInfo.ItemID == 3807 || model.itemInfo.ItemID == 3808)
        {
            return true;
        }
        return false;
    }

    private int Sort2(int Index)
    {
        int Max = 0;
        ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip, (int)RoleEquipType.retWing);
        if (itemModel == null)
        {
            return 0;
        }
        var wingConfig = Config.Instance.Get<WingRefineExpConfig>(_wingItemDic[Index]);
        if (WingDic[Index].GetUseDataModel((int)ItemUseDataKey.Def_IudetWingProgressValue) != null || WingDic[Index].GetUseDataModel((int)ItemUseDataKey.Def_IudetWingMaterialItemID) != null)
        {
            Max = wingConfig.EXPupper + GetWingRefiningValue(WingDic[Index]);
        }
        else
        {
            ItemModel model = playerPack.GetItemModelByIndex(PackType.rptItem, Index);
            for (int i = 0; i < model.itemInfo.ItemCount; i++)
            {
                if (wingConfig.EXPmaterial != null && !wingConfig.EXPmaterial.Equals(string.Empty))
                {
                    Dictionary<int, int> dicExp = ConfigParse.GetDic<int, int>(wingConfig.EXPmaterial);
                    Max = dicExp[itemModel.chinItemModel.LV];
                }
                else
                {
                    Max = wingConfig.EXPupper;
                }
            }
        }
        return Max;
    }

    private void SortAll()//翅膀总的排序
    {
        intPetAbsorbTyp.Sort(CompareAll);

    }
    int CompareAll(int x, int y)//数组排列
    {
        bool IsBoolx = ClassifyList.Contains(x);
        bool IsBooly = ClassifyList.Contains(y);
        if (IsBoolx.CompareTo(IsBooly) != 0)
        {
            return -IsBoolx.CompareTo(IsBooly);
        }
        if (ClassifyList.Contains(x) && ClassifyList.Contains(y))
        {
            var _sort_x1 = ClassifyList.IndexOf(x);
            var _sort_y1 = ClassifyList.IndexOf(y);
            return _sort_x1.CompareTo(_sort_y1);
        }
        else
        {
            var _sort_x = Sort2(x);
            var _sort_y = Sort2(y);
            return -_sort_x.CompareTo(_sort_y);
        }
     
    }
}