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

namespace Snxxz.UI
{
    [XLua.LuaCallCSharp]
    public class EquipTrainModel : Model, IBeforePlayerDataInitialize
    {
        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();

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

        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 override void Init()
        {
            ParseConfig();

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

        public override void UnInit()
        {
        }

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

        public void ResetOperateParams()
        {
            selectedLevel.value = 0;
            selectedPlace.value = 0;
            equipTrainLevel.value = 0;
            equipTrainMaxLevel.value = 0;
            material.value = Int3.zero;
            inevitableMaterialCount.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);
                }
            }
        }

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

            var material = GetTrainMaterial(equipPosition);
            if (material.z > material.y)
            {
                SysNotifyMgr.Instance.ShowTip("WashStone1");
                return;
            }

            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;
            }

            if (inevitableCount > 0)
            {
                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);

                var diamondNeed = (inevitableNeed - inevitableOwn) * GetInevitableMaterialPrice();
                var diamondOwn = PlayerDatas.Instance.baseData.diamond;

                if (diamondNeed > diamondOwn)
                {
                    WindowCenter.Instance.Open<RechargeTipWin>();
                    return;
                }

                if (diamondNeed > 0)
                {
                    if (!DayRemind.Instance.GetDayRemind(DayRemind.EQUIPTRAIN_COSTDIAMOND))
                    {
                        ConfirmCancel.ToggleConfirmCancel(Language.Get("Mail101"),
                            Language.Get("EquipWash103", inevitableNeed - inevitableOwn, diamondNeed),
                            Language.Get("TodayNoNotify"), (bool ok, bool isToggle) =>
                            {
                                if (isToggle)
                                {
                                    DayRemind.Instance.SetDayRemind(DayRemind.EQUIPTRAIN_COSTDIAMOND, true);
                                }

                                if (!ok)
                                {
                                    return;
                                }
                            });
                    }
                }
            }

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

        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;
            candidatePlaces.Clear();

            var places = GetTrainablePlaces(level);
            if (places.IsNullOrEmpty())
            {
                SelectPlace(new Int2(level, 0));
            }
            else
            {
                for (var i = 0; i < places.Count; i++)
                {
                    var place = places[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((EquipTrainCandidate x, EquipTrainCandidate y) =>
                {
                    var stateX = GetEquipPlaceTrainState(x.equipPosition);
                    var stateY = GetEquipPlaceTrainState(y.equipPosition);

                    if (stateX == TrainState.Allowable && stateY != TrainState.Allowable)
                    {
                        return -1;
                    }
                    else if (stateX != TrainState.Allowable && stateY == TrainState.Allowable)
                    {
                        return 1;
                    }
                    else if (stateX == TrainState.Allowable && stateY == TrainState.Allowable)
                    {
                        return x.trainLevel.value.CompareTo(y.trainLevel.value);
                    }
                    else if (stateX == TrainState.StarLimit && stateY != TrainState.StarLimit)
                    {
                        return -1;
                    }
                    else if (stateX != TrainState.StarLimit && stateY == TrainState.StarLimit)
                    {
                        return 1;
                    }
                    else if (stateX == TrainState.Empty && stateY != TrainState.Empty)
                    {
                        return -1;
                    }
                    else if (stateX != TrainState.Empty && stateY == TrainState.Empty)
                    {
                        return 1;
                    }
                    else
                    {
                        return 0;
                    }
                });
                SelectPlace(candidatePlaces[0].equipPosition);
            }
        }

        public void SelectPlace(Int2 equipPosition)
        {
            selectedPlace.value = equipPosition.y;
            selectedPlace.dirty = true;
            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 < 1)
            {
                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);
        }

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

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

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

        public int GetTotalLevel(int level)
        {
            if (!equipTrains.ContainsKey(level))
            {
                return 0;
            }

            return equipTrains[level].GetTotalLevel();
        }

        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 0;
            }

            var star = starModel.GetEquipStarLevel(equipPosition);
            var type = GetTrainType(equipPosition.y);
            var config = WashLevelMaxConfig.Get(type, star);
            if (config == null)
            {
                return 0;
            }
            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, 1, absoluteMax));
            if (data == null)
            {
                return TrainState.Empty;
            }

            var relativeMax = GetMaxTrainLevel(new Int2(equip.config.LV, equip.config.EquipPlace));
            if (relativeMax == 0)
            {
                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 List<int> GetTrainablePlaces(int level)
        {
            if (level <= 0)
            {
                return null;
            }

            var equipSet = equipModel.GetEquipSet(level);
            if (equipSet == null)
            {
                return null;
            }

            var places = new List<int>();
            for (var i = 1; i <= 12; i++)
            {
                var unLocked = equipSet.IsSlotUnLocked(i);
                if (unLocked)
                {
                    places.Add(i);
                }
            }

            return places;
        }

        private void InitTrainableProperties(Int2 equipPosition, TrainOperateType operateType)
        {
            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, 1, absoluteMax));

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

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

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

            inevitableMaterialCount.value = CalculateInevitableMaterialCount(equipPosition);
        }

        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);

                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 ParseConfig()
        {
            var config = FuncConfigConfig.Get("EquipWashGroup");
            trainTypes = ConfigParse.GetDic<int, int>(config.Numerical1);
        }

        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,
        }
    }
}