using System;
using System.Collections.Generic;
using Cal;
using Cal.DataTable;

namespace ET
{
    public static class ItemHelper
    {
        private static float randomMax;
        const float randomMin = -0.20f;

        public static void GenerateRandomMainAttribute(EquipItem self, Cal.DataTable.EquipBase equipBase, float randomMax)
        {
            ItemHelper.randomMax = randomMax;
            if (equipBase.Hp != 0)
            {
                self.SetMainAttribute(AttributeType.最大生命, GetRandom());
            }

            if (equipBase.Mp != 0)
            {
                self.SetMainAttribute(AttributeType.最大精力, GetRandom());
            }

            if (equipBase.Str != 0)
            {
                self.SetMainAttribute(AttributeType.力量, GetRandom());
            }

            if (equipBase.Quk != 0)
            {
                self.SetMainAttribute(AttributeType.敏捷, GetRandom());
            }

            if (equipBase.Spi != 0)
            {
                self.SetMainAttribute(AttributeType.精神, GetRandom());
            }

            if (equipBase.Wim != 0)
            {
                self.SetMainAttribute(AttributeType.智慧, GetRandom());
            }

            if (equipBase.Phy != 0)
            {
                self.SetMainAttribute(AttributeType.体质, GetRandom());
            }

            if (equipBase.Sta != 0)
            {
                self.SetMainAttribute(AttributeType.耐力, GetRandom());
            }

            if (equipBase.PhyAtk != 0)
            {
                self.SetMainAttribute(AttributeType.物理攻击, GetRandom());
            }

            if (equipBase.SpiAtk != 0)
            {
                self.SetMainAttribute(AttributeType.精神攻击, GetRandom());
            }

            if (equipBase.PhyDef != 0)
            {
                self.SetMainAttribute(AttributeType.物理防御, GetRandom());
            }

            if (equipBase.SpiDef != 0)
            {
                self.SetMainAttribute(AttributeType.精神防御, GetRandom());
            }

            if (equipBase.Pcrir != 0)
            {
                self.SetMainAttribute(AttributeType.物理暴击系数, GetRandom());
            }

            if (equipBase.Mcrir != 0)
            {
                self.SetMainAttribute(AttributeType.精神暴击系数, GetRandom());
            }

            if (equipBase.Pcri != 0)
            {
                self.SetMainAttribute(AttributeType.物理暴击效果, GetRandom());
            }

            if (equipBase.Mcri != 0)
            {
                self.SetMainAttribute(AttributeType.精神暴击效果, GetRandom());
            }

            if (equipBase.Rpcrir != 0)
            {
                self.SetMainAttribute(AttributeType.抗物理暴击系数, GetRandom());
            }

            if (equipBase.Rmcrir != 0)
            {
                self.SetMainAttribute(AttributeType.抗精神暴击系数, GetRandom());
            }

            if (equipBase.Rpcri != 0)
            {
                self.SetMainAttribute(AttributeType.抗物理暴击效果, GetRandom());
            }

            if (equipBase.Rmcri != 0)
            {
                self.SetMainAttribute(AttributeType.抗精神暴击效果, GetRandom());
            }

            if (equipBase.Dvo != 0)
            {
                self.SetMainAttribute(AttributeType.辅助值, GetRandom());
            }

            if (equipBase.Nphyi != 0)
            {
                self.SetMainAttribute(AttributeType.物理免伤, GetRandom());
            }

            if (equipBase.Nmeni != 0)
            {
                self.SetMainAttribute(AttributeType.精神免伤, GetRandom());
            }
        }

        static List<int> qualityWeightList = new() { 0, 1025, 856, 1 };

        public static void GenerateAdditionalAttribute(EquipItem self, int useLevel)
        {
            self.addtionalAttributes.Clear();
            int randCount = 0;
            if (MathHelper.IsHit(0.6f))
                randCount = 1;
            else if (MathHelper.IsHit(0.2f))
                randCount = 2;
            for (int i = 0; i < randCount; i++)
            {
                //稀有度
                int quality = MathHelper.GetProbabilityIndexByWeight(qualityWeightList);
                List<int> vidList = EquipAffixConfigCategory.Instance.vidDic[quality];
                if (vidList == null || vidList.Count == 0) continue;
                int vidCount = vidList.Count;
                int vid = vidList[RandomHelper.RandomNumber(0, vidCount)];
                List<int> levelList = EquipAffixConfigCategory.Instance.levelDic[vid];
                if (levelList == null || levelList.Count == 0) continue;
                int level = levelList[^1];
                for (int j = 0; j < levelList.Count; j++)
                {
                    if (useLevel < levelList[j])
                    {
                        if (j == 0) break;
                        level = levelList[j - 1];
                        break;
                    }
                }

                EquipAffixConfig equipAffix = EquipAffixConfigCategory.Instance.Get(vid * 100000 + quality * 10000 + level);
                if (equipAffix == null)
                {
                    Log.Error($"affix == null where vid = {vid} level = {level}");
                    continue;
                }

                self.addtionalAttributes.Add((int) equipAffix.Id);
            }
        }

        static readonly List<int> starSoulQualityWeightList = new() { 32, 4, 1 };

        private static readonly List<int> starSoulViceCountWeight = new()
        {
            0,
            15,
            60,
            20,
            5
        };

        public static StarSoulItem GenerateStarSoulItem(byte type, byte difficulty)
        {
            if (type == 0)
            {
                Log.Error($"type={type} difficulty={difficulty}");
                return null;
            }
            if (difficulty == 0)
            {
                Log.Error($"type={type} difficulty={difficulty}");
                return null;
            }

            var list= StarSoulTypeConfigCategory.Instance.idDic[type];
            if (list.Count != 0)
            {
                int id = list.RandomArray();
                return GenerateStarSoulItem(id, (Quality)difficulty);
            }

            return null;
        }
        public static StarSoulItem GenerateStarSoulItem(int typeId,Quality starQuality = Quality.Common)
        {
            StarSoulItem item = new();
            item.typeId = typeId;
            item.level = 0;
            item.exp = 0;
            int qualityInt = RandomHelper.RandomByWeight(starSoulQualityWeightList);
            if (qualityInt == -1)
                return null;
            qualityInt = (int) (starQuality + (byte) qualityInt);
            Quality quality = (Quality) qualityInt;
            item.quality = quality;
            item.Id = Game.IdGenerater.GenerateId();
            item.posType = (EquipType) RandomHelper.RandomNumber(0, 12);
            long mainId = GenerateMain(item.posType, quality);
            if (mainId == -1) return null;
            item.mainId = (int) mainId;
            GenerateVice(item);

            return item;

            static long GenerateMain(EquipType type,Quality qualityInt)
            {
                StarSoulEquipAttributeTypeConfig starSoulEquipAttributeTypeConfig =
                        StarSoulEquipAttributeTypeConfigCategory.Instance.Get((long) type);
                if (starSoulEquipAttributeTypeConfig == null) return -1;
                using var weightList = ListComponent<int>.Create();
                foreach (StarSoulEquipAttributeTypeConfig.AttributeType attributeType in starSoulEquipAttributeTypeConfig.AttributeTypeArr)
                {
                    weightList.List.Add(attributeType.Prob);
                }
                int mainIndex = RandomHelper.RandomByWeight(weightList.List);
                if (mainIndex == -1)
                {
                    Log.Error("配置表错误");
                    return -1;
                }

                byte key = starSoulEquipAttributeTypeConfig.AttributeTypeArr[mainIndex].Key;
                long Id= StarSoulAttributeConfigCategory.Instance.GetMainValue(qualityInt, key);
                
                return Id;
            }

            static void GenerateVice(StarSoulItem starSoulItem)
            {
                int count = RandomHelper.RandomByWeight(starSoulViceCountWeight);
                var list = StarSoulAttributeConfigCategory.Instance.viceKeyList;
                using var listComponent = ListComponent<long>.Create();
                for (int i = 0; i < count; i++)
                {
                    AddStarSoulViceAttribute(starSoulItem, list, listComponent, i);
                }
            }
        }

        private static void AddStarSoulViceAttribute(StarSoulItem starSoulItem, List<KeyValuePair<AttributeType, long>> list,
        ListComponent<long> listComponent, int index
        )
        {
            long id = 0;
            do
            {
                int weitIndex = RandomHelper.RandomByWeight(StarSoulAttributeConfigCategory.Instance.viceWeigt);
                if (weitIndex >= list.Count)
                {
                    Log.Error($"{weitIndex}>{list.Count}");
                    return;
                }

                id = list[weitIndex].Value;
            }
            while (listComponent.List.Contains(id));

            listComponent.List.Add(id);
            starSoulItem.viceIds[index] = (int) id;
        }

        public static float GetRealMainValue(float oldValue, byte level)
        {
            return oldValue*MathF.Pow(mainAddCoe, level);
        }
        private const float mainAddCoe = 1.1f;
        private const float reduceCoe = 0.8f;
        private const float reduceCoe1 = 0.6f;

        public static float GetRealViceValue(float oldValue, Quality quality) => quality switch
        {
            >=Quality.Legendary => oldValue,
            >=Quality.Rare => oldValue * reduceCoe,
            <=Quality.UnCommon => oldValue * (reduceCoe * reduceCoe1),
        };

        public static float GetRandom()
        {
            return GetRandom(randomMax);
        }

        public static float GetRandom(float randomMax)
        {
            float maxRandomMultier = randomMax;
            if (MathHelper.IsHit(0.4f))
            {
                maxRandomMultier -= 0.07f;
            }

            if (MathHelper.IsHit(0.1f))
            {
                maxRandomMultier -= 0.13f;
            }

            return RandomHelper.RandomFloat(randomMin, maxRandomMultier);
        }

        /// <summary>
        /// 升级一个副属性
        /// </summary>
        /// <param name="item"></param>
        /// <param name="attributeCount"></param>
        public static void UpgradeStarSoulItemVice(StarSoulItem item, int attributeCount)
        {
            int index = RandomHelper.RandomNumber(0,attributeCount);
            //强化第index个副属性
            float add = item.addViceCount switch
            {
                3 => RandomHelper.RandomFloat(ConstDefine.StarSoulViceAttributeAddArr1[0], ConstDefine.StarSoulViceAttributeAddArr1[1]),
                4 => RandomHelper.RandomFloat(ConstDefine.StarSoulViceAttributeAddArr2[0], ConstDefine.StarSoulViceAttributeAddArr2[1]),
                _ => RandomHelper.RandomFloat(ConstDefine.StarSoulViceAttributeAddArr[0], ConstDefine.StarSoulViceAttributeAddArr[1])
            };
            item.viceAdd[index] += add;
            item.addViceCount++;
        }

        /// <summary>
        /// 添加一个副属性
        /// </summary>
        /// <param name="item"></param>
        public static void AddStarSoulItemVice(StarSoulItem item)
        {
            int count = RandomHelper.RandomByWeight(starSoulViceCountWeight);
            var list = StarSoulAttributeConfigCategory.Instance.viceKeyList;
            using var listComponent = ListComponent<long>.Create();
            for (var i = 0; i < item.viceIds.Length; i++)
            {
                if (item.viceIds[i] == 0)
                {
                    AddStarSoulViceAttribute(item, list, listComponent, i);
                    return;
                }
            }
        }
    }
}