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

namespace vnxbqy.UI
{
    
    public class EquipTrainModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize
    {
        public readonly LogicInt selectedLevel = new LogicInt();
        public readonly LogicInt selectedPlace = new LogicInt();
        public readonly LogicInt equipTrainLevel = new LogicInt();
        public readonly LogicInt equipTrainMaxLevel = new LogicInt();
        public readonly LogicInt3 material = new LogicInt3();
        public readonly LogicInt inevitableMaterialCount = new LogicInt();
        public readonly LogicEnum<TrainOperateType> operateType = new LogicEnum<TrainOperateType>(TrainOperateType.None);
        public readonly LogicList<EquipTrainCandidate> candidatePlaces = new LogicList<EquipTrainCandidate>();
        public readonly LogicList<EquipTrainPropertyBar> propertyBars = new LogicList<EquipTrainPropertyBar>();
        public readonly LogicBool trainLimit = new LogicBool();
        public readonly LogicInt trainEffect = new LogicInt();

        static Dictionary<int, int> trainTypes = new Dictionary<int, int>();
        Dictionary<int, EquipTrainSet> equipTrains = new Dictionary<int, EquipTrainSet>();

        Redpoint redpoint = new Redpoint(106, 910000);
        bool redpointDirty = false;
        LogicUpdate logicUpdate = new LogicUpdate(1);

        EquipStarModel starModel { get { return ModelCenter.Instance.GetModel<EquipStarModel>(); } }
        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        EquipModel equipModel { get { return ModelCenter.Instance.GetModel<EquipModel>(); } }

        //自动洗炼至下一级（没有保存概念，自动洗练手动升级）
        public bool autoTrain = false; 

        public int limitLevel;

        public override void Init()
        {
            ParseConfig();

            var levels = equipModel.GetAllEquipSets();
            foreach (var level in levels)
            {
                if (level < limitLevel) continue;
                equipTrains[level] = new EquipTrainSet(level);
            }

            logicUpdate.Start(OnUpdate);

            packModel.refreshItemCountEvent += OnItemCountRefresh;
            autoTrain = false;
        }

        public override void UnInit()
        {
            packModel.refreshItemCountEvent -= OnItemCountRefresh;
        }

        public void OnBeforePlayerDataInitialize()
        {
            foreach (var train in equipTrains.Values)
            {
                train.Reset();
            }
        }

        public void OnAfterPlayerDataInitialize()
        {
            redpointDirty = true;
        }

        public void ResetOperateParams()
        {
            selectedLevel.value = 0;
            selectedPlace.value = 0;
            equipTrainLevel.value = 0;
            equipTrainMaxLevel.value = 0;
            material.value = Int3.zero;
            inevitableMaterialCount.value = 0;
            trainEffect.value = 0;
            operateType.value = TrainOperateType.None;
            candidatePlaces.Clear();
            propertyBars.Clear();
        }

        public void UpdateEquipTrainInfo(HA3BB_tagMCEquipPartXLAttrInfo info)
        {
            foreach (var item in info.InfoList)
            {
                var clientEquipPlace = EquipSet.ServerPlaceToClientPlace(item.EquipPlace);
                var trainLevel = item.XLAttrLV;
                if (equipTrains.ContainsKey(clientEquipPlace.x))
                {
                    var equipTrain = equipTrains[clientEquipPlace.x];
                    var unSavedProperties = Int3.zero;
                    var trainedProperties = Int3.zero;
                    for (int i = 0; i < item.XLAttrList.Length; i++)
                    {
                        var property = item.XLAttrList[i];
                        trainedProperties[i] = (int)property.XLAttrValue;
                        unSavedProperties[i] = (int)(property.XLAttrChange > 0 ? property.XLAttrChange - property.XLAttrValue : 0);
                    }

                    equipTrain.UpdateEquipTrainLevel(clientEquipPlace.y, trainLevel);
                    equipTrain.UpdateTrainedProperties(clientEquipPlace.y, trainedProperties);
                    equipTrain.UpdateUnSavedProperties(clientEquipPlace.y, unSavedProperties);

                    if (clientEquipPlace.x == selectedLevel.value && clientEquipPlace.y == selectedPlace.value)
                    {
                        equipTrainLevel.value = trainLevel;
                        for (int i = 0; i < propertyBars.Count; i++)
                        {
                            var bar = propertyBars[i];
                            bar.deltaValue.value = unSavedProperties[i];
                            bar.propertyValue.value = trainedProperties[i];
                        }
                    }
                }
            }

            if (selectedLevel.value > 0)
            {
                var equipPosition = new Int2(selectedLevel.value, selectedPlace.value);
                var trainState = GetEquipPlaceTrainState(equipPosition);
                equipTrainLevel.value = GetTrainLevel(equipPosition);
                equipTrainMaxLevel.value = trainState == TrainState.Empty ? -1 : GetMaxTrainLevel(equipPosition);
                material.value = GetTrainMaterial(equipPosition);

                operateType.value = CalculateTrainOperateType(equipPosition);
                InitTrainableProperties(equipPosition, operateType.value);
                UpdateTrainLimitState(equipPosition);
            }

            if (candidatePlaces.Count > 0)
            {
                for (int i = 0; i < candidatePlaces.Count; i++)
                {
                    candidatePlaces[i].trainLevel.value = GetTrainLevel(candidatePlaces[i].equipPosition);
                }
            }

            redpointDirty = true;
        }

        
        public void Train(Int2 equipPosition, bool[] inevitables)
        {
            var maxLevel = GetMaxTrainLevel(equipPosition);
            if (maxLevel < 0)
            {
                SysNotifyMgr.Instance.ShowTip("WashStarRequirement");
                return;
            }

            var material = GetTrainMaterial(equipPosition);
            if (material.z > material.y)
            {

                SysNotifyMgr.Instance.ShowTip("WashStone1");
                return;
            }

            LimitedTimeLuxuryGiftModel.Instance.IsItemIdShow(3, material.x, material.z, 1, 0);
            var code = 0;
            var inevitableCount = 0;
            for (int i = 0; i < inevitables.Length; i++)
            {
                inevitableCount += inevitables[i] ? 1 : 0;
                code += inevitables[i] ? MathUtility.Power(2, i) : 0;
            }

            Action processTrain = () =>
            {
                trainEffect.dirty = true;
                trainEffect.value = code > 0 ? 2 : 1;

                var equipWash = new CA325_tagCMEquipXLAttrChange();
                equipWash.EquipPlace = (byte)EquipSet.ClientPlaceToServerPlace(equipPosition);
                equipWash.CheckUseGoldAttr = (byte)code;
                GameNetSystem.Instance.SendInfo(equipWash);
                autoTrain = true;

            };

            if (inevitableCount == 0)
            {
                processTrain();
                return;
            }

            var trainLevel = GetTrainLevel(equipPosition);
            var trainType = GetTrainType(equipPosition.y);
            var config = EquipWashConfig.Get(trainType, trainLevel);

            var inevitableNeed = config != null ? config.mustCosts[inevitableCount - 1] : 0;
            var inevitableOwn = packModel.GetItemCountByID(PackType.Item, GeneralDefine.equipTrainMustItemId);

            if (inevitableOwn >= inevitableNeed)
            {
                processTrain();
                return;
            }

            var diamondNeed = (inevitableNeed - inevitableOwn) * GetInevitableMaterialPrice();
            var diamondOwn = PlayerDatas.Instance.baseData.diamond;
            LimitedTimeLuxuryGiftModel.Instance.IsItemIdShow(52, 1, diamondNeed, 2, 0);

            if (diamondNeed > diamondOwn)
            {
                WindowCenter.Instance.Open<RechargeTipWin>();
                return;
            }
            if (DayRemind.Instance.GetDayRemind(DayRemind.EQUIPTRAIN_COSTDIAMOND))
            {
                processTrain();
                return;
            }
            autoTrain = false;
            ConfirmCancel.ToggleConfirmCancel(Language.Get("Mail101"),
                Language.Get("EquipWash103", inevitableNeed - inevitableOwn, diamondNeed),
                Language.Get("TodayNoNotify"), (bool ok, bool isToggle) =>
                {

                    if (ok)
                    {
                        processTrain();
                    }
                    if (isToggle)
                    {
                        DayRemind.Instance.SetDayRemind(DayRemind.EQUIPTRAIN_COSTDIAMOND, true);
                    }
                    else
                    {
                        autoTrain = false;
                    }
                });

        }

        public void Save(Int2 equipPosition)
        {
            var result = new CA326_tagCMEquipXLAttrChangeOK();
            result.EquipPlace = (byte)EquipSet.ClientPlaceToServerPlace(equipPosition);
            result.IsSave = 1;
            GameNetSystem.Instance.SendInfo(result);
        }

        public void GiveUp(Int2 equipPosition)
        {
            var result = new CA326_tagCMEquipXLAttrChangeOK();
            result.EquipPlace = (byte)EquipSet.ClientPlaceToServerPlace(equipPosition);
            result.IsSave = 0;
            GameNetSystem.Instance.SendInfo(result);
        }

        public void UpdateLevel(Int2 equipPosition)
        {
            var result = new CA326_tagCMEquipXLAttrChangeOK();
            result.EquipPlace = (byte)EquipSet.ClientPlaceToServerPlace(equipPosition);
            result.IsSave = 2;
            GameNetSystem.Instance.SendInfo(result);
        }

        public void SelectLevel(int level)
        {
            selectedLevel.value = level;
            selectedLevel.dirty = true;
            candidatePlaces.Clear();

            if (level > 0)
            {
                for (var i = 1; i <= 12; i++)
                {
                    var place = i;
                    var equipPosition = new Int2(level, place);

                    var trainCandidate = new EquipTrainCandidate(equipPosition);
                    trainCandidate.trainLevel.value = GetTrainLevel(equipPosition);
                    trainCandidate.equipGuid.value = equipModel.GetEquip(equipPosition);
                    trainCandidate.starLevel.value = starModel.GetEquipStarLevel(equipPosition);
                    candidatePlaces.Add(trainCandidate);
                }

                candidatePlaces.Sort(EquipTrainCandidateCompare);
                SelectPlace(candidatePlaces[0].equipPosition);
            }
            else
            {
                SelectPlace(Int2.zero);
            }
        }

        public void SelectPlace(Int2 equipPosition)
        {
            selectedPlace.value = equipPosition.y;
            selectedPlace.dirty = true;

            if (equipPosition.x > 0 && equipPosition.y >= 1 && equipPosition.y <= 12)
            {
                for (int i = 0; i < candidatePlaces.Count; i++)
                {
                    var candidate = candidatePlaces[i];
                    candidate.selected.value = candidate.equipPosition == equipPosition;
                }

                var trainState = GetEquipPlaceTrainState(equipPosition);
                equipTrainLevel.value = GetTrainLevel(equipPosition);
                equipTrainMaxLevel.value = trainState == TrainState.Empty ? -1 : GetMaxTrainLevel(equipPosition);
                equipTrainMaxLevel.dirty = true;
                material.value = GetTrainMaterial(equipPosition);

                operateType.value = CalculateTrainOperateType(equipPosition);
                InitTrainableProperties(equipPosition, operateType.value);
                UpdateTrainLimitState(equipPosition);
            }
        }

        public void SetInevitable(int index, bool invevitable)
        {
            var equipPosition = new Int2(selectedLevel.value, selectedPlace.value);
            var state = GetEquipPlaceTrainState(equipPosition);

            var unsavedProperties = GetUnSavedProperties(equipPosition);
            if (unsavedProperties != Int3.zero)
            {
                SysNotifyMgr.Instance.ShowTip("WashUnSavedTip");
                return;
            }

            var maxLevel = GetMaxTrainLevel(equipPosition);
            if (maxLevel < 0)
            {
                SysNotifyMgr.Instance.ShowTip("WashStarRequirement");
                return;
            }

            if (state == TrainState.Empty)
            {
                SysNotifyMgr.Instance.ShowTip("Wash_NoEquip1");
                return;
            }

            if (state == TrainState.StarLimit)
            {
                SysNotifyMgr.Instance.ShowTip("WashStarRequirement");
                return;
            }

            if (invevitable)
            {
                var properties = GetTrainedProperties(equipPosition);
                var type = GetTrainType(selectedPlace.value);
                var trainLevel = GetTrainLevel(equipPosition);
                var data = EquipWashConfig.Get(type, trainLevel);
                var isPerfect = false;
                switch (index)
                {
                    case 0:
                        isPerfect = properties[index] >= data.config.attMax1;
                        break;
                    case 1:
                        isPerfect = properties[index] >= data.config.attMax2;
                        break;
                    case 2:
                        isPerfect = properties[index] >= data.config.attMax3;
                        break;
                }

                if (isPerfect)
                {
                    SysNotifyMgr.Instance.ShowTip("WashOperateTip1");
                    return;
                }
            }

            if (propertyBars.Count > index)
            {
                propertyBars[index].inevitable.value = invevitable;
            }

            inevitableMaterialCount.value = CalculateInevitableMaterialCount(equipPosition);
            inevitableMaterialCount.dirty = true; //相同值不改变的情况下无法刷新 会是锁定状态
        }

        public Int2 GetRecommendEquipPosition()
        {
            foreach (var trainSet in equipTrains.Values)
            {
                var level = trainSet.level;
                for (var i = 1; i <= 12; i++)
                {
                    var isRedpoint = trainSet.GetRedpointState(i) != RedPointState.None;
                    if (isRedpoint)
                    {
                        return new Int2(level, i);
                    }
                }
            }

            return new Int2(limitLevel, 1);
        }

        public int GetTrainLevel(Int2 equipPosition)
        {
            var equip = equipModel.GetEquip(equipPosition);
            if (string.IsNullOrEmpty(equip))
            {
                return -1;
            }

            if (!equipTrains.ContainsKey(equipPosition.x))
            {
                return -1;
            }

            var maxLevel = GetMaxTrainLevel(equipPosition);
            return Mathf.Min(maxLevel, equipTrains[equipPosition.x].GetTrainLevel(equipPosition.y));
        }

        public int GetTrainLevelEx(Int2 equipPosition)
        {
            var equip = equipModel.GetEquip(equipPosition);
            if (string.IsNullOrEmpty(equip))
            {
                return 0;
            }

            if (!equipTrains.ContainsKey(equipPosition.x))
            {
                return 0;
            }

            return equipTrains[equipPosition.x].GetTrainLevel(equipPosition.y);
        }


        public int GetMaterialNeed(Int2 equipPosition)
        {
            var level = GetTrainLevel(equipPosition);
            var type = GetTrainType(equipPosition.y);
            var data = EquipWashConfig.Get(type, level);

            return data.config.costCount;
        }

        public int GetMaxTrainLevel(int place)
        {
            var type = GetTrainType(place);
            return WashLevelMaxConfig.GetMaxLevel(type);
        }

        public int GetMaxTrainLevel(Int2 equipPosition)
        {
            var equip = equipModel.GetEquip(equipPosition);
            if (string.IsNullOrEmpty(equip))
            {
                return -1;
            }

            var star = starModel.GetEquipStarLevel(equipPosition);
            var type = GetTrainType(equipPosition.y);
            var config = WashLevelMaxConfig.Get(type, star);
            if (config == null)
            {
                return -1;
            }
            else
            {
                return config.levelMax;
            }
        }

        public TrainState GetEquipPlaceTrainState(Int2 equipPosition)
        {
            var equipGuid = equipModel.GetEquip(equipPosition);
            if (string.IsNullOrEmpty(equipGuid))
            {
                return TrainState.Empty;
            }

            var equip = packModel.GetItemByGuid(equipGuid);
            if (equip == null)
            {
                return TrainState.Empty;
            }

            var type = GetTrainType(equipPosition.y);
            var currentTrainLevel = GetTrainLevel(equipPosition);
            var absoluteMax = GetMaxTrainLevel(equipPosition.y);
            var data = EquipWashConfig.Get(type, Mathf.Clamp(currentTrainLevel, 0, absoluteMax));
            if (data == null)
            {
                return TrainState.Empty;
            }

            var relativeMax = GetMaxTrainLevel(new Int2(equip.config.LV, equip.config.EquipPlace));
            if (relativeMax == -1)
            {
                return TrainState.StarLimit;
            }

            var properties = GetTrainedProperties(equipPosition);
            var isFull = properties.x >= data.config.attMax1
                && properties.y >= data.config.attMax2
                && properties.z >= data.config.attMax3;
            if (isFull)
            {
                if (currentTrainLevel >= absoluteMax)
                {
                    return TrainState.MaxLevel;
                }

                if (currentTrainLevel >= relativeMax)
                {
                    return TrainState.StarLimit;
                }
            }

            return TrainState.Allowable;
        }

        public Int3 GetUnSavedProperties(Int2 equipPosition)
        {
            return equipTrains.ContainsKey(equipPosition.x) ? equipTrains[equipPosition.x].GetUnSavedProperties(equipPosition.y) : Int3.zero;
        }

        public Int3 GetTrainedProperties(Int2 equipPosition)
        {
            var equip = equipModel.GetEquip(equipPosition);
            if (string.IsNullOrEmpty(equip))
            {
                return Int3.zero;
            }

            if (!equipTrains.ContainsKey(equipPosition.x))
            {
                return Int3.zero;
            }

            var maxLevel = GetMaxTrainLevel(equipPosition);
            var trainedProperties = equipTrains[equipPosition.x].GetTrainedProperties(equipPosition.y);
            var type = GetTrainType(equipPosition.y);
            var data = EquipWashConfig.Get(type, maxLevel);

            var property1 = 0;
            var property2 = 0;
            var property3 = 0;
            if (data != null)
            {
                property1 = Mathf.Min(trainedProperties.x, data.config.attMax1);
                property2 = Mathf.Min(trainedProperties.y, data.config.attMax2);
                property3 = Mathf.Min(trainedProperties.z, data.config.attMax3);
            }

            return new Int3(property1, property2, property3);
        }

        private void InitTrainableProperties(Int2 equipPosition, TrainOperateType operateType)
        {
            //此段代码特殊处理，因为 propertyBars.Clear();
            bool ison1 = false;
            bool ison2 = false;
            bool ison3 = false;
            if (propertyBars.Count == 3)
            {
                ison1 = propertyBars[0].inevitable.value;
                ison2 = propertyBars[1].inevitable.value;
                ison3 = propertyBars[2].inevitable.value;
            }
            ///=============================
            
            propertyBars.Clear();
            var trainState = GetEquipPlaceTrainState(equipPosition);
            var absoluteMax = GetMaxTrainLevel(equipPosition.y);

            var unSavedProperties = GetUnSavedProperties(equipPosition);
            var trainedProperties = GetTrainedProperties(equipPosition);
            var trainLevel = GetTrainLevel(equipPosition);
            var data = EquipWashConfig.Get(GetTrainType(equipPosition.y), Mathf.Clamp(trainLevel, 0, absoluteMax));

            if (data != null)
            {
                var propertyBar = new EquipTrainPropertyBar(data.config.attType1, data.config.attMax1, data.config.attCostMoney1, trainState);
                propertyBar.propertyValue.value = trainedProperties.x;
                propertyBar.deltaValue.value = unSavedProperties.x;
                propertyBar.operateType.value = operateType;
                propertyBar.inevitable.value = ison1;
                propertyBars.Add(propertyBar);

                propertyBar = new EquipTrainPropertyBar(data.config.attType2, data.config.attMax2, data.config.attCostMoney2, trainState);
                propertyBar.propertyValue.value = trainedProperties.y;
                propertyBar.deltaValue.value = unSavedProperties.y;
                propertyBar.operateType.value = operateType;
                propertyBar.inevitable.value = ison2;
                propertyBars.Add(propertyBar);

                propertyBar = new EquipTrainPropertyBar(data.config.attType3, data.config.attMax3, data.config.attCostMoney3, trainState);
                propertyBar.propertyValue.value = trainedProperties.z;
                propertyBar.deltaValue.value = unSavedProperties.z;
                propertyBar.operateType.value = operateType;
                propertyBar.inevitable.value = ison3;
                propertyBars.Add(propertyBar);
            }

            inevitableMaterialCount.value = CalculateInevitableMaterialCount(equipPosition);
            inevitableMaterialCount.dirty = true; //相同值不改变的情况下无法刷新 会是锁定状态
        }

        private Int3 GetTrainMaterial(Int2 equipPosition)
        {
            if (GetEquipPlaceTrainState(equipPosition) == TrainState.Allowable)
            {
                var type = GetTrainType(equipPosition.y);
                var level = GetTrainLevel(equipPosition);
                var data = EquipWashConfig.Get(type, level);
                var count = packModel.GetItemCountByID(PackType.Item, data.config.costItem);
                var need = GetMaterialNeed(equipPosition);
                return new Int3(data.config.costItem, count, need);
            }
            else
            {
                return Int3.zero;
            }
        }

        public int GetInevitableMaterialPrice()
        {
            var config = StoreConfig.GetStoreCfg(GeneralDefine.equipTrainMustItemId, 1);
            return config != null ? config.MoneyNumber : 0;
        }

        private int CalculateInevitableMaterialCount(Int2 equipPosition)
        {
            var count = 0;
            for (int i = 0; i < propertyBars.Count; i++)
            {
                count += propertyBars[i].inevitable.value ? 1 : 0;
            }

            if (count > 0)
            {
                var type = GetTrainType(equipPosition.y);
                var trainLevel = GetTrainLevel(equipPosition);
                var config = EquipWashConfig.Get(type, trainLevel);
                if (config == null)
                    return 0;
                return config.mustCosts[count - 1];
            }
            else
            {
                return 0;
            }
        }

        private TrainOperateType CalculateTrainOperateType(Int2 equipPosition)
        {
            var trainState = GetEquipPlaceTrainState(equipPosition);
            if (trainState == TrainState.StarLimit || trainState == TrainState.MaxLevel)
            {
                return TrainOperateType.Max;
            }

            var properties = GetTrainedProperties(equipPosition);
            var equip = packModel.GetItemByGuid(equipModel.GetEquip(equipPosition));
            if (equip == null)
            {
                return TrainOperateType.None;
            }

            var type = GetTrainType(equip.config.EquipPlace);
            var trainLevel = GetTrainLevel(equipPosition);

            var data = EquipWashConfig.Get(type, trainLevel);
            if (properties.x >= data.config.attMax1 && properties.y >= data.config.attMax2 && properties.z >= data.config.attMax3)
            {
                return TrainOperateType.LevelUp;
            }

            var unSavedProperties = GetUnSavedProperties(equipPosition);
            if (unSavedProperties != Int3.zero)
            {
                return TrainOperateType.Save;
            }

            if (trainState == TrainState.Allowable)
            {
                return TrainOperateType.Train;
            }

            return TrainOperateType.None;
        }

        private void UpdateTrainLimitState(Int2 equipPosition)
        {
            var type = GetTrainType(equipPosition.y);
            var currentLevel = GetTrainLevel(equipPosition);
            var data = EquipWashConfig.Get(type, currentLevel);
            if (data == null)
            {
                trainLimit.value = false;
            }
            else
            {
                var properties = GetTrainedProperties(equipPosition);
                var isFull = properties.x >= data.config.attMax1
                    && properties.y >= data.config.attMax2
                    && properties.z >= data.config.attMax3;

                var trainState = GetEquipPlaceTrainState(equipPosition);
                trainLimit.value = isFull && (trainState == TrainState.StarLimit || trainState == TrainState.MaxLevel);
            }
        }

        private void OnItemCountRefresh(PackType type, int index, int itemId)
        {
            switch (type)
            {
                case PackType.Item:
                    if (itemId == 5303)
                    {
                        redpointDirty = true;
                    }
                    break;
                case PackType.Equip:
                    var clientEquipPosition = EquipSet.ServerPlaceToClientPlace(index);
                    if (clientEquipPosition.x > 0)
                    {
                        redpointDirty = true;
                    }
                    break;
            }
        }

        private void UpdateTrainRedpoint()
        {
            var ownTrainMaterial = packModel.GetItemCountByID(PackType.Item, 5303);
            var targetEquipPosition = Int2.zero;
            if (ownTrainMaterial != 0)
            {
                var minTrainLevel = 999;
                foreach (var trainSet in equipTrains.Values)
                {
                    var level = trainSet.level;
                    for (var i = 1; i <= 12; i++)
                    {
                        var trainState = GetEquipPlaceTrainState(new Int2(level, i));
                        if (trainState != TrainState.Allowable)
                        {
                            continue;
                        }

                        var needMaterial = GetMaterialNeed(new Int2(level, i));
                        if (needMaterial > ownTrainMaterial)
                        {
                            continue;
                        }

                        var tranLevel = trainSet.GetTrainLevel(i);
                        if (tranLevel < minTrainLevel)
                        {
                            minTrainLevel = tranLevel;
                            targetEquipPosition = new Int2(level, i);
                        }
                    }
                }
            }

            foreach (var trainSet in equipTrains.Values)
            {
                var level = trainSet.level;
                for (var i = 1; i <= 12; i++)
                {
                    var isRedpoint = level == targetEquipPosition.x && i == targetEquipPosition.y;
                    trainSet.UpdateRedpoint(i, isRedpoint ? RedPointState.Simple : RedPointState.None);
                }
            }

        }

        private void OnUpdate()
        {
            if (redpointDirty && FuncOpen.Instance.IsFuncOpen(91))
            {
                redpointDirty = false;
                UpdateTrainRedpoint();
            }
        }

        private int EquipTrainCandidateCompare(EquipTrainCandidate x, EquipTrainCandidate y)
        {
            var stateX = GetEquipPlaceTrainState(x.equipPosition);
            var stateY = GetEquipPlaceTrainState(y.equipPosition);

            if (stateX == TrainState.Allowable && stateY != TrainState.Allowable)
            {
                return -1;
            }

            if (stateX != TrainState.Allowable && stateY == TrainState.Allowable)
            {
                return 1;
            }

            if (stateX == TrainState.Allowable && stateY == TrainState.Allowable)
            {
                var compareResult = x.trainLevel.value.CompareTo(y.trainLevel.value);
                if (compareResult == 0)
                {
                    var factorX = x.equipPosition.x * 100 + x.equipPosition.y;
                    var factorY = y.equipPosition.x * 100 + y.equipPosition.y;
                    compareResult = factorX.CompareTo(factorY);
                }

                return compareResult;
            }

            if (stateX == TrainState.StarLimit && stateY != TrainState.StarLimit)
            {
                return -1;
            }
            else if (stateX != TrainState.StarLimit && stateY == TrainState.StarLimit)
            {
                return 1;
            }
            else if (stateX == TrainState.MaxLevel && stateY != TrainState.MaxLevel)
            {
                return -1;
            }
            else if (stateX != TrainState.MaxLevel && stateY == TrainState.MaxLevel)
            {
                return 1;
            }
            else if (stateX == TrainState.Empty && stateY != TrainState.Empty)
            {
                return -1;
            }
            else if (stateX != TrainState.Empty && stateY == TrainState.Empty)
            {
                return 1;
            }
            else
            {
                return x.equipPosition.y.CompareTo(y.equipPosition.y);
            }
        }

        private void ParseConfig()
        {
            var config = FuncConfigConfig.Get("EquipWashGroup");
            trainTypes = ConfigParse.GetDic<int, int>(config.Numerical1);

            if (equipModel.EquipLevelFuncID == null)
                equipModel.ParseEquipLevelFuncID();
            limitLevel = equipModel.EquipLevelFuncID[91];
        }

        public static int GetTrainType(int place)
        {
            return trainTypes.ContainsKey(place) ? trainTypes[place] : 0;
        }

        public enum TrainOperateType
        {
            None = 0,
            Train = 1,
            Forbid = 2,
            Save = 3,
            LevelUp = 4,
            Max = 5,
        }

        public enum TrainState
        {
            Empty,
            StarLimit,
            MaxLevel,
            Allowable,
        }
    }
}