using Amazon.SecurityToken.Model.Internal.MarshallTransformations;
using Common.Utils;
using System.Text.Json.Serialization;
using CommonDomain.Enum;
using MongoDB.Bson.Serialization.Attributes;
using static CommonDomain.BaseModel.BossConfig.BossBombConfig;

namespace CommonDomain.BaseModel
{
    public static class GlobalRandom
    {
        private static readonly Random _instance = new Random();
        private static readonly object _lock = new object();

        public static int Next(int maxValue) => Next(0, maxValue);

        public static int Next(int minValue, int maxValue)
        {
            lock (_lock)
            {
                return _instance.Next(minValue, maxValue);
            }
        }

        public static long NextInt64(long minValue, long maxValue)
        {
            lock (_lock)
            {
                return _instance.NextInt64(minValue, maxValue);
            }
        }

        public static int NextInclusive(int value1, int value2)
        {
            var minValue = Math.Min(value1, value2);
            var maxValue = Math.Max(value1, value2);
            if (minValue == maxValue)
                return minValue;

            lock (_lock)
            {
                return (int)_instance.NextInt64(minValue, (long)maxValue + 1);
            }
        }

        public static double NextDouble()
        {
            lock (_lock)
            {
                return _instance.NextDouble();
            }
        }
    }
    [BsonIgnoreExtraElements]
    public class FishTypeConfig
    {
        public string FishNumber { get; set; } = string.Empty;

        public string FishName { get; set; } = string.Empty;


        public string FishBrief { get; set; } = string.Empty;

        public FishTypeEnum FishType { get; set; }


        public int FishScore { get; set; } = 0;

        public int KillWeight { get; set; } = 0;

        [BsonElement("pathList")]
        public List<int> PathList { get; set; } = new List<int>();

        public string FishImage { get; set; } = string.Empty;

        public string FishMultipleDesc { get; set; } = string.Empty;
    }

    [BsonIgnoreExtraElements]
    public class RoomConfig
    {
        public string RoomNumber { get; set; } = string.Empty;

        public string RoomName { get; set; } = string.Empty;

        public GameTypeEnum GameType { get; set; }

        public int RoomLevel { get; set; } = 0;

        public int RoomPartitionNum { get; set; } = 0;

        public int RoomCount { get; set; } = 0;

        public int RoomGoldLimit { get; set; } = 0;

        public List<int> CannonMultipleList { get; set; } = new List<int>();

    }

    [BsonIgnoreExtraElements]
    public class RoomFishConfig
    {
        public GameTypeEnum GameType { get; set; }

        public List<RoomFishDetailConfig> NormalFishList { get; set; } = new List<RoomFishDetailConfig>();


        public List<RoomFishLevelConfig> RoomFishLevelList { get; set; } = new List<RoomFishLevelConfig>();



        public List<RoomFishProbabilityConfig> RoomFishProbabilityList { get; set; } = new List<RoomFishProbabilityConfig>();


    }
    public class RoomFishProbabilityConfig
    {

        public int RoomLevel { get; set; } = 0;
        public int Type { get; set; } = 0;

        public FishTypeEnum FishType { get; set; }

        public List<int> FirstFishCountRange { get; set; } 
        public List<int> TimeRange { get; set; } 

        
        public List<int> CountRange { get; set; }


        public List<int> MaxCountRange { get; set; } 


    }

    [BsonIgnoreExtraElements]
    public class RoomFishLevelConfig : RoomFishDetailConfig
    {
        public int RoomLevel { get; set; } = 0;


    }

    [BsonIgnoreExtraElements]
    public class RoomFishDetailConfig
    {

        public int Type { get; set; } = 0;

        public string FishNumber { get; set; } = string.Empty;
        public int FishWeight { get; set; } = 0;
        public int FishFrequency { get; set; } = 0;
        public int MaxCount { get; set; } = 0;

        public int Times { get; set; } = 0;
    }

    [BsonIgnoreExtraElements]
    public class FishArrayConfig
    {
        public FishArrayConfig()
        {
        }

        public FishArrayConfig(string fishArrayNumber, string name, string fishNumber, int fishCount, string bossFishNumber, int boosCount, string arrayNumber, List<int> thresholdList)
        {
            FishArrayNumber = fishArrayNumber;
            Name = name;
            FishNumber = fishNumber;
            FishCount = fishCount;
            BossFishNumber = bossFishNumber;
            BoosCount = boosCount;
            ArrayNumber = arrayNumber;
            ThresholdList = thresholdList;
        }

        public string FishArrayNumber { get; set; } = string.Empty;

        public string Name { get; set; } = string.Empty;

        public string FishNumber { get; set; } = string.Empty;
        public int FishCount { get; set; } = 0;

        public string BossFishNumber { get; set; } = string.Empty;

        public int BoosCount { get; set; } = 0;

        public string ArrayNumber { get; set; } = string.Empty;


        public List<int> ThresholdList { get; set; } = new List<int>();

        public double GenerateFrequency { get; set; } = 0.2;

    }
    [BsonIgnoreExtraElements]
    public class UserLevelConfig
    {
        public int Level { get; set; } = 0;
        public long ExpMin { get; set; } = 0;
        public long ExpMax { get; set; } = 0;

        public long Gold { get; set; } = 0;
        public int Diamond { get; set; } = 0;

        public List<BaseProductCount> ProductList { get; set; } = new List<BaseProductCount>();

        public List<GiftConfig> GiftList { get; set; } = new List<GiftConfig>();
    }
    [BsonIgnoreExtraElements]
    public class PropInfConfig : BasePropInfo
    {
        public List<string> GameNumber { get; set; } = new List<string>();

        public int Day { get; set; } = 0;
    }

    [BsonIgnoreExtraElements]
    public class PropFragmentConfig : BasePropInfo
    {
        public int FragmentCount { get; set; } = 0;
        public string ProductNumber { get; set; } = string.Empty;
    }
    [BsonIgnoreExtraElements]
    public class BasePropInfo : BaseProduct
    {
        public SaleTypeEnum SaleType { get; set; } = SaleTypeEnum.金币;

        public int Price { get; set; } = 0;
        public int SaleCount { get; set; } = 1;

        public int VIPPrice { get; set; } = 0;

        public int DealerPrice { get; set; } = 0;

        public bool IsEnable { get; set; } = true;

        public bool IsSale { get; set; } = true;
    }
    [BsonIgnoreExtraElements]
    public class VipLevelConfig
    {
        public int Level { get; set; } = 0;

        public long ExpMax { get; set; } = 0;

        public long ExpMin { get; set; } = 0;

        public double SignInAdd { get; set; } = 0;

        public string Remark { get; set; } = string.Empty;

        public List<GiftConfig> GiftList { get; set; } = new List<GiftConfig>();

        public List<GiftConfig> DailyGift { get; set; } = new List<GiftConfig>();


    }
    [BsonIgnoreExtraElements]
    public class GiftConfig
    {

        public int Type { get; set; } = 0;

        public string OtherId { get; set; } = string.Empty;

        public bool IsRandom { get; set; } = false;

        public int Count { get; set; } = 0;

        public int MinCount { get; set; } = 0;

        public int MaxCount { get; set; } = 0;

        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
        public BaseProduct? Product { get; set; }

    }


    [BsonIgnoreExtraElements]
    public class KillConfig
    {

        public int NormalizationFactorPlayer { get; set; } = 50000;
        public double MinPlayerModifier { get; set; } = 0.3;
        public double MaxPlayerModifier { get; set; } = 2.0;
        public int TargetSystemProfit { get; set; } = 1000000;
        public int NormalizationFactorSystem { get; set; } = 10000000;
        public double MinSystemModifier { get; set; } = 0.95;
        public double MaxSystemModifier { get; set; } = 1.05;

        public int DaySystemGold { get; set; } = 100000;

        public int IPCount { get; set; } = 5;

        public double ViolateValue { get; set; } = 0.2;
        public CompensateRateParam CompensateRate { get; set; } = new CompensateRateParam();


        public CompensateRateParam PenaltyRate { get; set; } = new CompensateRateParam();

        public long GlobalAnnounceMinGold { get; set; } = 0;

    }

    [BsonIgnoreExtraElements]
    public class CompensateRateParam
    {
        public double BossRate { get; set; } = 1;


        public double GoldRate { get; set; } = 1;


        public double SpecialRate { get; set; } = 1;

        public double Ordinary { get; set; } = 1;
    }

    [BsonIgnoreExtraElements]
    public class BossConfig
    {

        public List<LuckWheelConfig> LuckWheel { get; set; } = new List<LuckWheelConfig>();

        public LuckPokerConfig LuckPoker { get; set; } = new LuckPokerConfig();

        public List<LuckFlyDiskConfig> LuckFlyDisk { get; set; } = new List<LuckFlyDiskConfig>();

        public BaseBossConfig FullScreen { get; set; } = new BaseBossConfig();
        public BaseBossConfig Range { get; set; } = new BaseBossConfig();

        public AmmunitionBoxConfig AmmunitionBox { get; set; } = new AmmunitionBoxConfig();

        public InterstellarCruiseConfig InterstellarCruise { get; set; } = new InterstellarCruiseConfig();

        public BossFlameStormConfig FlameStorm { get; set; } = new BossFlameStormConfig();

        public BossBombConfig Bomb { get; set; } = new BossBombConfig();

        public BossScorpionConfig Scorpion { get; set; } = new BossScorpionConfig();

        public List<BossProbabilityConfig> Probability { get; set; } = new List<BossProbabilityConfig>();

        public List<LuckDragonConfig> LuckDragon { get; set; } = new List<LuckDragonConfig>();


        public static int GetBossProbabilityConfigResponse(List<BossProbabilityConfigParam> configParams)
        {
            int totalWeight = configParams.Sum(p => p.TriggerRate);

            if (totalWeight <= 0)
            {
                return 0;
            }

            int randomValue = GlobalRandom.Next(0, totalWeight);

            int currentWeightSum = 0;
            foreach (var param in configParams)
            {
                currentWeightSum += param.TriggerRate;

                if (randomValue < currentWeightSum)
                {
                    return GlobalRandom.NextInclusive(param.Min, param.Max);
                }
            }

            return 0;
        }


        public static CruiseConfigCount GetRandomCountConfigOption(List<CruiseConfigCount> options)
        {
            if (options == null || !options.Any())
            {
                return null;
            }

            long totalWeight = options.Sum(o => (long)o.TriggerRate);

            if (totalWeight <= 0)
            {
                return null;
            }

            long randomValue = GlobalRandom.NextInt64(0, totalWeight);

            long currentWeightSum = 0;
            foreach (var option in options)
            {
                currentWeightSum += option.TriggerRate;

                if (randomValue < currentWeightSum)
                {
                    return option;
                }
            }

            return options.FirstOrDefault(o => o.TriggerRate > 0);
        }


        public class CruiseConfigCount
        {

            public int Count { get; set; }
            public int TriggerRate { get; set; } = 0;

            public int KillRate { get; set; } = 0;

        }

        public class LuckDragonConfig:BaseBossConfig
        {


            public List<BossProbabilityConfigParam> OuterConfig { get; set; } = new List<BossProbabilityConfigParam>();
            public List<BossProbabilityConfigParam> MiddleConfig { get; set; } = new List<BossProbabilityConfigParam>();

            public List<BossProbabilityConfigParam> InnerConfig { get; set; } = new List<BossProbabilityConfigParam>();

            public (List<int> option, int beizhu, string ringName) GetResponse()
            {
                int beishu = 1;
                var result = new List<int>();
                string ringName = "外圈";
                int outerResult = GetBossProbabilityConfigResponse(OuterConfig);
                result.Add(outerResult);
                if (outerResult == -1)
                {
                    int middleResult = GetBossProbabilityConfigResponse(MiddleConfig);
                    result.Add(middleResult);
                    if (middleResult == -1)
                    {
                        int innerResult = GetBossProbabilityConfigResponse(InnerConfig);
                        result.Add(innerResult);
                        beishu = innerResult;
                        ringName = "内圈";
                    }
                    else {
                        beishu = middleResult;
                        ringName = "中圈";
                    }
                }
                else {
                    beishu = outerResult;
                    ringName = "外圈";
                }

                return (result, beishu, ringName);
            }



        }

        public class BossBombConfig:BaseBossConfig
        { 
            public List<CruiseConfigCount> CountConfig { get; set; } = new List<CruiseConfigCount>();

            public List<BossProbabilityConfigParam> OneDeathConfig { get; set; } = new List<BossProbabilityConfigParam>();

            public List<BossProbabilityConfigParam> TwoDeathConfig { get; set; } = new List<BossProbabilityConfigParam>();

            public (int beishu, int type) GetResponse(string fishId)
            {

                int beishu = 0;
                var countConfig = GetRandomCountConfigOption(CountConfig);
                if (countConfig == null)
                    return (1, 1);
                if (countConfig.Count == 1)
                {
                    beishu = GetBossProbabilityConfigResponse(OneDeathConfig);
                    return (beishu, 1);
                }
                else
                {
                    beishu = GetBossProbabilityConfigResponse(TwoDeathConfig);
                    return (beishu, 2);
                }
            }

        }

        public class ScorpionItemCountConfig
        {
            public int Count { get; set; } = 0;
            public int Weight { get; set; } = 0;
        }

        public class ScorpionItemConfig
        {
            public string PropNumber { get; set; } = string.Empty;
            public int Count { get; set; } = 0;
            public int Weight { get; set; } = 0;
        }

        public class BossScorpionConfig : BaseBossConfig
        {
            public List<ScorpionItemCountConfig> ItemCountConfig { get; set; } = new List<ScorpionItemCountConfig>();

            public List<ScorpionItemConfig> ItemConfig { get; set; } = new List<ScorpionItemConfig>();

            public List<BossProbabilityConfigParam> GoldConfig { get; set; } = new List<BossProbabilityConfigParam>();

            public int CompositeMultiplier { get; set; } = 650;

            public double KillProbability { get { return CompositeMultiplier <= 0 ? 0 : 1.0 / CompositeMultiplier; } }

            public double ComputedWeight { get { return CompositeMultiplier <= 0 ? 0 : 10000.0 / CompositeMultiplier; } }

            private static ScorpionItemCountConfig GetRandomItemCount(List<ScorpionItemCountConfig> options)
            {
                if (options == null || !options.Any()) return null;
                long totalWeight = options.Sum(o => (long)o.Weight);
                if (totalWeight <= 0) return null;
                long randomValue = GlobalRandom.NextInt64(0, totalWeight);
                long currentWeightSum = 0;
                foreach (var option in options)
                {
                    currentWeightSum += option.Weight;
                    if (randomValue < currentWeightSum)
                        return option;
                }
                return options.FirstOrDefault(o => o.Weight > 0);
            }

            private static ScorpionItemConfig GetRandomItem(List<ScorpionItemConfig> options)
            {
                if (options == null || !options.Any()) return null;
                long totalWeight = options.Sum(o => (long)o.Weight);
                if (totalWeight <= 0) return null;
                long randomValue = GlobalRandom.NextInt64(0, totalWeight);
                long currentWeightSum = 0;
                foreach (var option in options)
                {
                    currentWeightSum += option.Weight;
                    if (randomValue < currentWeightSum)
                        return option;
                }
                return options.FirstOrDefault(o => o.Weight > 0);
            }

            public (int beishu, List<ScorpionItemConfig> items) GetResponse()
            {
                int beishu = GetBossProbabilityConfigResponse(GoldConfig);

                var items = new List<ScorpionItemConfig>();
                var countConfig = GetRandomItemCount(ItemCountConfig);
                int itemCount = countConfig?.Count ?? 0;
                for (int i = 0; i < itemCount; i++)
                {
                    var item = GetRandomItem(ItemConfig);
                    if (item != null)
                        items.Add(item);
                }
                return (beishu, items);
            }
        }

        public class BossFlameStormConfig : BaseBossConfig
        {

            public List<CruiseConfigCount> CountConfig { get; set; } = new List<CruiseConfigCount>();

            public List<List<BossProbabilityConfigParam>> DeathConfigs { get; set; } = new List<List<BossProbabilityConfigParam>>();



            public (bool isKill, int beishu, string fishId, int animId) GetResponse(string fishId)
            {
                var countConfig = GetRandomCountConfigOption(CountConfig);
                if (countConfig == null)
                    return (true, 1, fishId, GlobalRandom.Next(2, 5));

                if (DeathConfigs.Count == 0)
                    return (countConfig.Count > 1, 1, fishId, countConfig.Count > 1 ? GlobalRandom.Next(2, 5) : 1);

                int index = Math.Max(0, countConfig.Count - 1);
                if (index >= DeathConfigs.Count)
                    index = DeathConfigs.Count - 1;

                int beishu = GetBossProbabilityConfigResponse(DeathConfigs[index]);

                if (countConfig.Count == 1)
                    return (false, beishu, fishId, 1);

                return (true, beishu, fishId, GlobalRandom.Next(2, 5));
            }


        }
        public class InterstellarCruiseConfig : BaseBossConfig
        {

            public List<CruiseConfigCount> CountConfig { get; set; } = new List<CruiseConfigCount>();

            public List<List<BossProbabilityConfigParam>> DeathConfigs { get; set; } = new List<List<BossProbabilityConfigParam>>();


            public (bool isKill, int beishu, string fishId, int animId) GetResponse(string fishId)
            {
                var countConfig = GetRandomCountConfigOption(CountConfig);
                if (countConfig == null)
                    return (true, 1, fishId, GlobalRandom.Next(2, 5));

                if (DeathConfigs.Count == 0)
                    return (countConfig.Count > 1, 1, fishId, countConfig.Count > 1 ? GlobalRandom.Next(2, 5) : 1);

                int index = Math.Max(0, countConfig.Count - 1);
                if (index >= DeathConfigs.Count)
                    index = DeathConfigs.Count - 1;

                int beishu = GetBossProbabilityConfigResponse(DeathConfigs[index]);

                if (countConfig.Count == 1)
                    return (false, beishu, fishId, 1);

                return (true, beishu, fishId, GlobalRandom.Next(2, 5));
            }


        }
        public class BossProbabilityConfig : BaseBossConfig
        {

            public List<BossProbabilityConfigParam> configParams { get; set; } = new List<BossProbabilityConfigParam>();


            public int GetResponse()
            {
                int totalWeight = configParams.Sum(p => p.TriggerRate);

                if (totalWeight <= 0)
                {
                    return 0;
                }

                int randomValue = GlobalRandom.Next(0, totalWeight);

                int currentWeightSum = 0;
                foreach (var param in configParams)
                {
                    currentWeightSum += param.TriggerRate;

                    if (randomValue < currentWeightSum)
                    {
                        return GlobalRandom.NextInclusive(param.Min, param.Max);
                    }
                }

                return 0;
            }


        }
        public class AmmunitionBoxConfig : BaseBossConfig
        {
            public List<BossOptionBaseParam> OptionList { get; set; } = new List<BossOptionBaseParam>();
            public List<BossOptionBaseParam> GetResponse()
            {
                var opt = RandomBossOption.GetRandomBossOption(OptionList);
                if (opt == null)
                    return null;
                return new List<BossOptionBaseParam>() { opt };
            }
        }

        public class LuckFlyDiskConfig : BaseBossConfig
        {

            public List<BossOptionBaseParam> InnerOptionList { get; set; } = new List<BossOptionBaseParam>();
            public List<BossOptionBaseParam> OuterOptionList { get; set; } = new List<BossOptionBaseParam>();

            public List<BossOptionBaseParam> GetResponse()
            {
                List<BossOptionBaseParam> result = new List<BossOptionBaseParam>();
                var opt = RandomBossOption.GetRandomBossOption(InnerOptionList);
                result.Add(opt);
                var opt1 = RandomBossOption.GetRandomBossOption(OuterOptionList);
                result.Add(opt1);
                return result;

            }
        }
        public class LuckPokerConfig : BaseBossConfig
        {
            public List<BossOptionBaseParam> OptionList { get; set; } = new List<BossOptionBaseParam>();

            public List<BossOptionBaseParam> GetResponse()
            {
                var opt = RandomBossOption.GetRandomBossOption(OptionList);
                if (opt == null)
                    return null;
                return new List<BossOptionBaseParam>() { opt };
            }
        }
        public class LuckWheelConfig : BaseBossConfig
        {
            public List<BossOptionBaseParam> OptionList { get; set; } = new List<BossOptionBaseParam>();

            public List<BossOptionBaseParam> CountList { get; set; } = new List<BossOptionBaseParam>();
            public List<BossOptionBaseParam> GetResponse()
            {
                List<double> count = new List<double>();
                List<BossOptionBaseParam> option = new List<BossOptionBaseParam>();

                foreach (var item in CountList)
                {
                    if (item.TriggerRate >= 100)
                    {
                        count.Add(item.OptionId);
                        continue;
                    }
                    if (GlobalRandom.Next(100) < item.TriggerRate)
                    {
                        count.Add(item.OptionId);
                        continue;
                    }
                    break;
                }
                foreach (var item in count)
                {
                    var opt = RandomBossOption.GetRandomBossOption(OptionList);
                    if (opt == null)
                        continue;
                    option.Add(opt);
                }
                return option;
            }

        }

        public class BaseBossConfig
        {
            public List<string> FishNumber { get; set; } = new List<string>();
        }

        public class BossProbabilityConfigParam
        {
            public BossProbabilityConfigParam(int min, int max, int triggerRate)
            {
                Min = min;
                Max = max;
                TriggerRate = triggerRate;
            }

            public int Min { get; set; }
            public int Max { get; set; }
            public int TriggerRate { get; set; } = 0;
        }
    }

    public class BossDropItemConfig
    {
        public string PropNumber { get; set; } = string.Empty;
        public string PropName { get; set; } = string.Empty;
        public int Count { get; set; } = 1;
        public int Weight { get; set; } = 0;
    }

    public class BossDropConfig
    {
        public int NoDropWeight { get; set; } = 5000;
        public List<BossDropItemConfig> DropItems { get; set; } = new List<BossDropItemConfig>();
    }

    public class BossOptionBaseParam
    {
        public BossOptionBaseParam(double optionId, int triggerRate, double score = 0)
        {
            OptionId = optionId;
            TriggerRate = triggerRate;
            Score = score;
        }

        public double OptionId { get; set; }


        public int TriggerRate { get; set; } = 0;

        public double Score { get; set; } = 0;
    }
    public static class RandomBossOption
    {
        public static BossOptionBaseParam GetRandomBossOption(List<BossOptionBaseParam> options)
        {
            if (options == null || !options.Any())
            {
                return null;
            }

            long totalWeight = options.Sum(o => (long)o.TriggerRate);

            if (totalWeight <= 0)
            {
                return null;
            }

            long randomValue = GlobalRandom.NextInt64(0, totalWeight);

            long currentWeightSum = 0;
            foreach (var option in options)
            {
                currentWeightSum += option.TriggerRate;

                if (randomValue < currentWeightSum)
                {
                    return option;
                }
            }

            return options.FirstOrDefault(o => o.TriggerRate > 0);
        }
    }

    public class ScratchCardConfig
    {

        public int Type { get; set; } = 0;

        public BaseProduct? BaseProduct { get; set; }


        public int Count { get; set; } = 0;

        public int Weight { get; set; } = 0;
    }

    public class ChessConfig
    {
        public List<int> CreateRoomLimit { get; set; } = new List<int>();

        public long MinBetGold { get; set; } = 1000;

        public List<long> BetGoldLimits { get; set; } = new List<long>();

        public List<int> CreateRoomVipLevels { get; set; } = new List<int>();

    }

    public class FishRoomConfig
    {
        public List<int> SeatSelectLimit { get; set; } = new List<int>();

        public List<int> SeatSelectVipLevels { get; set; } = new List<int>();
    }

    public class TorpedoRewardConfig
    {
        public int MinGold { get; set; }
        public int MaxGold { get; set; }
        public int Weight { get; set; }
    }

    public class TorpedoItemConfig
    {
        public string Number { get; set; } = string.Empty;
        public string Name { get; set; } = string.Empty;
        public string Color { get; set; } = string.Empty;
        public List<TorpedoRewardConfig> RewardRanges { get; set; } = new();
    }
}