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

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

        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 ResetOperateParams()
        {
            selectedLevel.value = 0;
            selectedPlace.value = 0;
            equipTrainLevel.value = 0;
            equipTrainMaxLevel.value = 0;
            material.value = 0;
            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 level = selectedLevel.value;
                var place = selectedPlace.value;
                var trainState = GetEquipPlaceTrainState(level, place);
                equipTrainLevel.value = GetTrainLevel(level, place);
                equipTrainMaxLevel.value = trainState == TrainState.Empty ? -1 : GetMaxTrainLevel(level, place);
                material.value = GetTrainMaterial(level, place);

                operateType.value = CalculateTrainOperateType(level, place);
                InitTrainableProperties(level, place, operateType.value);
            }

        }

        public void Train(int level, int place, bool[] inevitables)
        {
            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;
            }

            var need = GetMaterialNeed(level, place);
            var itemId = GetTrainMaterial(level, place);
            var own = packModel.GetItemCountByID(PackType.Item, itemId);
            if (need > own)
            {
                return;
            }

            if (inevitableCount > 0)
            {
                var trainLevel = GetTrainLevel(level, place);
                var trainType = GetTrainType(place);
                var config = EquipWashConfig.Get(trainType, trainLevel + 1);
                var moneyNeed = config != null ? config.mustCosts[inevitableCount - 1] : 0;
                var moneyOwn = PlayerDatas.Instance.baseData.diamond;

                if (moneyNeed > moneyOwn)
                {
                    return;
                }
            }

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

        public void Save(int level, int place)
        {
            var result = new CA326_tagCMEquipXLAttrChangeOK();
            result.EquipPlace = (byte)EquipSet.ClientPlaceToServerPlace(level, place);
            result.IsSave = 1;
            GameNetSystem.Instance.SendInfo(result);
        }

        public void GiveUp(int level, int place)
        {
            var result = new CA326_tagCMEquipXLAttrChangeOK();
            result.EquipPlace = (byte)EquipSet.ClientPlaceToServerPlace(level, place);
            result.IsSave = 0;
            GameNetSystem.Instance.SendInfo(result);
        }

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

            var places = GetTrainablePlaces(level);
            if (places.IsNullOrEmpty())
            {
                SelectPlace(level, 0);
            }
            else
            {
                for (var i = 0; i < places.Count; i++)
                {
                    var place = places[i];
                    candidatePlaces.Add(new EquipTrainCandidate(level, place));
                    if (i == 0)
                    {
                        SelectPlace(level, place);
                    }
                }
            }
        }

        public void SelectPlace(int level, int place)
        {
            selectedPlace.value = place;
            selectedPlace.dirty = true;
            for (int i = 0; i < candidatePlaces.Count; i++)
            {
                var candidate = candidatePlaces[i];
                candidate.selected.value = candidate.level == level && candidate.place == place;
            }

            var trainState = GetEquipPlaceTrainState(level, place);
            equipTrainLevel.value = GetTrainLevel(level, place);
            equipTrainMaxLevel.value = trainState == TrainState.Empty ? -1 : GetMaxTrainLevel(level, place);
            material.value = GetTrainMaterial(level, place);

            operateType.value = CalculateTrainOperateType(level, place);
            InitTrainableProperties(level, place, operateType.value);
        }

        public void SetInevitable(int index, bool invevitable)
        {
            var equipGuid = equipModel.GetEquip(selectedLevel.value, selectedPlace.value);
            if (string.IsNullOrEmpty(equipGuid))
            {
                SysNotifyMgr.Instance.ShowTip("Wash_NoEquip1");
                return;
            }

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

                if (isPerfect)
                {
                    return;
                }
            }

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

            inevitableMaterialCount.value = CalculateInevitableMaterialCount();
        }

        public int GetTrainLevel(int level, int place)
        {
            if (!equipTrains.ContainsKey(level))
            {
                return 0;
            }

            return equipTrains[level].GetTrainLevel(place);
        }

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

            return equipTrains[level].GetTotalLevel();
        }

        public int GetMaterialNeed(int level, int place)
        {
            var star = starModel.GetEquipStarLevel(level, place);
            var type = GetTrainType(place);
            var data = EquipWashConfig.Get(type, star + 1);

            return data.config.costCount;
        }

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

        public int GetMaxTrainLevel(int level, int place)
        {
            var star = starModel.GetEquipStarLevel(level, place);
            var type = GetTrainType(place);
            var config = WashLevelMaxConfig.Get(type, star);
            if (config == null)
            {
                return 0;
            }
            else
            {
                return config.levelMax;
            }
        }

        public List<EquipTrainCandidate> GetCandidatePlaces()
        {
            return candidatePlaces.Fetch();
        }

        public TrainState GetEquipPlaceTrainState(int level, int place)
        {
            var equipGuid = equipModel.GetEquip(level, place);
            if (string.IsNullOrEmpty(equipGuid))
            {
                return TrainState.Empty;
            }

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

            var type = GetTrainType(place);
            var currentStarLevel = GetTrainLevel(level, place);
            var absoluteMax = GetMaxTrainLevel(place);
            var data = EquipWashConfig.Get(type, Mathf.Clamp(currentStarLevel, 1, absoluteMax));
            if (data == null)
            {
                return TrainState.Empty;
            }

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

                var relativeMax = GetMaxTrainLevel(equip.config.LV, equip.config.EquipPlace);
                if (currentStarLevel >= relativeMax)
                {
                    return TrainState.StarLimit;
                }
            }

            return TrainState.Allowable;
        }

        public Int3 GetUnSavedProperties(int level, int place)
        {
            return equipTrains.ContainsKey(level) ? equipTrains[level].GetUnSavedProperties(place) : Int3.zero;
        }

        public Int3 GetTrainedProperties(int level, int place)
        {
            return equipTrains.ContainsKey(level) ? equipTrains[level].GetTrainedProperties(place) : Int3.zero;
        }

        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(int level, int place, TrainOperateType operateType)
        {
            propertyBars.Clear();
            var trainState = GetEquipPlaceTrainState(level, place);
            var absoluteMax = GetMaxTrainLevel(place);

            var unSavedProperties = GetUnSavedProperties(level, place);
            var trainedProperties = GetTrainedProperties(level, place);
            var trainLevel = GetTrainLevel(level, place);
            var data = EquipWashConfig.Get(GetTrainType(place), Mathf.Clamp(trainLevel, 1, absoluteMax));

            if (data != null)
            {
                var propertyBar = new EquipTrainPropertyBar(data.config.attType1, trainState == TrainState.Empty ? 0 : 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, trainState == TrainState.Empty ? 0 : 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, trainState == TrainState.Empty ? 0 : data.config.attMax3, trainState);
                propertyBar.propertyValue.value = trainedProperties.z;
                propertyBar.deltaValue.value = unSavedProperties.z;
                propertyBar.operateType.value = operateType;
                propertyBars.Add(propertyBar);
            }

            inevitableMaterialCount.value = CalculateInevitableMaterialCount();
        }

        private int GetTrainMaterial(int level, int place)
        {
            if (GetEquipPlaceTrainState(level, place) == TrainState.Allowable)
            {
                var star = starModel.GetEquipStarLevel(level, place);
                var type = GetTrainType(place);
                var data = EquipWashConfig.Get(type, star + 1);
                return data.config.costItem;
            }
            else
            {
                return 0;
            }
        }

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

            return count;
        }

        private TrainOperateType CalculateTrainOperateType(int level, int place)
        {
            var unSavedProperties = GetUnSavedProperties(level, place);
            if (unSavedProperties != Int3.zero)
            {
                return TrainOperateType.Save;
            }

            var trainState = GetEquipPlaceTrainState(level, place);
            if (trainState == TrainState.Allowable)
            {
                return TrainOperateType.Train;
            }

            if (trainState == TrainState.StarLimit || trainState == TrainState.MaxLevel)
            {
                return TrainOperateType.Max;
            }

            return TrainOperateType.None;
        }

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

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

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

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