using System;
using System.Linq;
using UnityEngine;
using cfg;
using LitJson;
using System.Collections.Generic;
using asap.core;
using game;
using UnityEngine.UI;

namespace GameCore
{
    public class FishWeightData
    {
        public int Level;
        public float MaxG;
        //public float TotalG;
        //public int MaxPTS;
        //public long TotalPTS;
        public int TotalCard;
        public int TotalNum;
        public bool NewFish = true;
        //public float fishRate;
        public string Serialize()
        {
            //return $"{Level}|{MaxG}|{TotalG}|{MaxPTS}|{TotalPTS}|{TotalCard}|{TotalNum}|{NewFish}|{fishRate}";
            return $"{Level}|{MaxG}|{TotalCard}|{TotalNum}|{NewFish}";
        }
        public static FishWeightData Deserialize(string s)
        {
            string[] arr = s.Split('|');
            FishWeightData data = new FishWeightData();
            if (arr.Length == 9)
            {
                data.Level = int.Parse(arr[0]);
                data.MaxG = float.Parse(arr[1]);
                data.TotalCard = int.Parse(arr[5]);
                data.TotalNum = int.Parse(arr[6]);
                data.NewFish = bool.Parse(arr[7]);
            }
            else if (arr.Length == 5)
            {
                data.Level = int.Parse(arr[0]);
                data.MaxG = float.Parse(arr[1]);
                data.TotalCard = int.Parse(arr[2]);
                data.TotalNum = int.Parse(arr[3]);
                data.NewFish = bool.Parse(arr[4]);
            }
            return data;
        }
    }
    public partial class PlayerFishData
    {
        private cfg.Tables _tables;
        public PlayerFishData(cfg.Tables tables)
        {
            this._tables = tables;
        }
        Dictionary<int, Dictionary<int, FishWeightData>> mapFishData = new Dictionary<int, Dictionary<int, FishWeightData>>();
        Dictionary<int, int> mapProgress = new Dictionary<int, int>();

        Dictionary<int, FishWeightData> fishData = new Dictionary<int, FishWeightData>();
        Dictionary<int, int> fishCardData = new Dictionary<int, int>();
        //鱼杆星级 和 鱼杆碎片数量
        Dictionary<int, int> rodData = new Dictionary<int, int>();
        Dictionary<int, int> rodLevelData = new Dictionary<int, int>();
        //每个地图上的的游弋鱼 item map
        Dictionary<int, int> fishSwimToMap = new Dictionary<int, int>();
        Dictionary<int, int> fishSwimToMapCount = new Dictionary<int, int>();

        bool _isRedPoint_up;
        bool RodCanUp = false;
        bool RodCanUpLevel = false;
        public int MapTipforUnlocked;
        public bool IsOpenMap = false;
        public bool IsOpenRod = false;
        //public bool IsOpenAutoFish = false;

        public float InitBotLuck;
        public float InitFishLuck;
        public int BotCount = 0;
        public Dictionary<string, float> LuckDataDic = new Dictionary<string, float>();
        public bool IsOpenPiercing = false;
        public int RodSelectedInPack = 0;
        public void InitData(Dictionary<string, string> userDatas)
        {
            string data_value;
            if (userDatas.TryGetValue("RodData", out data_value))
            {
                rodData = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<int, int>>(data_value);
            }

            if (userDatas.TryGetValue("RodLevelData", out data_value))
            {
                rodLevelData = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<int, int>>(data_value);
            }

            if (userDatas.TryGetValue("FishSwimToMap", out data_value))
            {
                fishSwimToMap = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<int, int>>(data_value);
            }

            if (userDatas.TryGetValue("FishSwimToMapCount", out data_value))
            {
                fishSwimToMapCount = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<int, int>>(data_value);
            }

            if (userDatas.TryGetValue("MapProgress", out data_value))
            {
                InitMapProgress(data_value);
            }

            if (userDatas.TryGetValue(InitRodAccessoriesDataKey, out data_value))
            {
                InitRodAccessoriesData(data_value);
            }
            if (userDatas.TryGetValue(HonorLevelDataKey, out data_value))
            {
                _honorlevel = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<int, int>>(data_value);
            }
            Dictionary<int, MapData> mapTBData = _tables.TbMapData.DataMap;
            foreach (var map in mapTBData)
            {
                if (userDatas.TryGetValue($"Map_5_{map.Key}", out data_value))
                {
                    Dictionary<int, string> mapDataStr = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<int, string>>(data_value);
                    Dictionary<int, FishWeightData> mapData = new Dictionary<int, FishWeightData>();
                    foreach (var item in mapDataStr)
                    {
                        mapData[item.Key] = FishWeightData.Deserialize(item.Value);
                    }
                    SetFishAllData(map.Key, mapData);
                }
                else if (userDatas.TryGetValue($"Map_{map.Key}", out data_value))
                {
                    //兼容老数据
                    Dictionary<int, FishWeightData> mapData = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<int, FishWeightData>>(data_value);

                    SetFishAllData(map.Key, mapData);
                }
            }
#if AGG
            int lv = GetAllLevel();
            GEvent.SetProp("fishcard_level", lv);
            GEvent.SetUserProp("fishcard_level", lv);
#endif
        }

        float FishMaxG(FishData fishData, int level, float maxG)
        {
            var _fishWeight = fishData.BaseWeight * fishData.PointExtraParam * (1 + fishData.WeightRandom);
            if (level > 0)
            {
                FishCard fishCard = _tables.TbFishCard.GetOrDefault(fishData.FishCardID);
                if (fishCard == null)
                {
                    return _fishWeight;
                }
                var weightIncEvent = fishCard.WeightMagList[level - 1];
                _fishWeight *= (1 + weightIncEvent);
            }
            _fishWeight = Mathf.Round(_fishWeight * 100) / 100;
            if (maxG > _fishWeight)
            {
                //Debug.LogWarning($"FishMaxG: fishID={fishData.ID}, level={level}, maxG={maxG}, _fishWeight={_fishWeight}");
                return _fishWeight;
            }
            else
            {
                return maxG;
            }
        }

        public int GetDiffFishCount()
        {
            return fishData.Count;
        }
        public int GetAnglingCount()
        {
            return GContext.container.Resolve<PlayerData>()._fishingFrequency;
        }
        //public int GetFishingCount()
        //{
        //    SmallGameData smallGameData = GContext.container.Resolve<SmallGameData>();
        //    return _fishingFrequency - smallGameData.BombGameCount - smallGameData.HeistGameCount;
        //}

        public void Init()
        {
            InitRodAccessoriesData();
            InitLuck();
            InitRod();
        }
        void InitLuck()
        {
            var config = _tables.TbGlobalConfig;
            if (!LuckDataDic.TryGetValue("InitBotLuck", out InitBotLuck))
            {
                InitBotLuck = config.InitBotLuck;
            }
            if (!LuckDataDic.TryGetValue("InitFishLuck", out InitFishLuck))
            {
                InitFishLuck = config.InitFishLuck;
            }
            float botCount;
            if (!LuckDataDic.TryGetValue("BotCount", out botCount))
            {
                botCount = 0;
            }
            BotCount = (int)botCount;
        }
        /// <summary>
        /// 修改幸运值
        /// </summary>
        /// <param name="value">鱼的品质 0=》漂流瓶</param>
        public void SetBotCount(int value)
        {
            //添加幸运值
            if (value > 5)
            {
                return;
            }
            float luck = GContext.container.Resolve<PlayerData>().GetLuckMultipier();
            var config = _tables.TbGlobalConfig;
            if (value == 0)
            {
                BotCount++;
                InitBotLuck += config.ModifierToBotLuck[0] * luck;
            }
            else
            {
                InitBotLuck += config.ModifierToBotLuck[1] * luck;
                MoreFish moreFish = GContext.container.Resolve<BuffDataCenter>().GetWeelyBuffTimeData<MoreFish>();
                if (moreFish != null && moreFish.Quality == value)
                {
                    InitFishLuck += moreFish.ModifierToFishLuck * luck;
                }
                else
                {
                    InitFishLuck += config.ModifierToFishLuck[value - 1] * luck;
                }

                BotCount = 0;
            }
            if (InitFishLuck < 0)
            {
                InitFishLuck = 0;
            }
            if (InitBotLuck < 0)
            {
                InitBotLuck = 0;
            }
            GameDebug.Log("InitBotLuck:" + InitBotLuck + " InitFishLuck:" + InitFishLuck + " BotCount:" + BotCount);
            LuckDataDic["InitFishLuck"] = InitFishLuck;
            LuckDataDic["InitBotLuck"] = InitBotLuck;
            LuckDataDic["BotCount"] = BotCount;
            GContext.container.Resolve<PlayerData>().SavePlayerData();
        }
        void InitRod()
        {
            if (!rodData.ContainsKey(_tables.TbRodData.DataList[0].ID))
            {
                rodData[_tables.TbRodData.DataList[0].ID] = 0;
            }
            else
            {
                CheckRodRedPointUp();
                CheckAllRodUpLevel();
            }
        }
        public void CheckRodRedPointUp()
        {
            _isRedPoint_up = false;
            RodCanUp = false;
            List<RodData> rodDatas = _tables.TbRodData.DataList;
            RodAscend rodAscend;
            for (int i = 0; i < rodDatas.Count; i++)
            {
                rodAscend = _tables.TbRodAscend[rodDatas[i].AscendID];
                if (rodData.TryGetValue(rodAscend.FragmentID, out int itemCount))
                {
                    if (rodData.TryGetValue(rodDatas[i].ID, out int star))
                    {
                        if (rodAscend.MaxAscent > star && itemCount >= rodAscend.AscentTransformed[star + 1])
                        {
                            RodCanUp = true;
                            _isRedPoint_up = true;
                            break;
                        }
                    }
                    else
                    {
                        if (itemCount >= rodAscend.AscentTransformed[0])
                        {
                            _isRedPoint_up = true;
                            break;
                        }
                    }
                }
            }
            SetRedPoint();
        }
        public bool CheckRodUpLevelByID(int id)
        {
            RodData rodDataA = _tables.TbRodData.GetOrDefault(id);
            bool isUp = CheckRodUpLevel(rodDataA);
            return isUp;
        }
        public bool CheckRodUpLevel(RodData rodDataA)
        {
            bool isUp = false;
            if (rodData.TryGetValue(rodDataA.ID, out int star))
            {
                RodLevelup rodLevelup = _tables.TbRodLevelup.GetOrDefault(rodDataA.LevelupID);
                int level = GetRodLevel(rodDataA.ID) + 1;//数据从0开始，显示从1开始
                bool isMax = rodLevelup.MaxLevel <= level;
                if (!isMax)
                {
                    var fragment = GContext.container.Resolve<PlayerData>().pearl;
                    var requireNum = rodLevelup.LevelupConsume[level];

                    List<int> Millestones = rodLevelup.Millestones;
                    int maxLevel = level + 1;

                    for (int i = 0; i < Millestones.Count; i++)
                    {
                        if (i == star)
                        {
                            maxLevel = Millestones[i];
                            break;
                        }
                    }
                    if (maxLevel > level && fragment >= requireNum)
                    {
                        isUp = true;
                    }
                }
            }
            return isUp;
        }
        public void CheckAllRodUpLevel()
        {
            RodCanUpLevel = false;
            List<RodData> rodDatas = _tables.TbRodData.DataList;
            for (int j = 0; j < rodDatas.Count; j++)
            {
                RodData rodDataA = rodDatas[j];

                RodCanUpLevel = CheckRodUpLevel(rodDataA);
                if (RodCanUpLevel)
                {
                    break;
                }
            }
            SetRedPoint();
        }
        public void SetRedPoint()
        {
            PlayerData playerData = GContext.container.Resolve<PlayerData>();
            //bool isUp = CheckRodUpLevelByID(playerData.equipRodID);
            RedPointManager.Instance.SetRedPointState(RedPointName.Home_Rod, RodCanUpLevel || _isRedPoint_up || playerData.newRodList.Count > 0);
        }
        public ExchangeItemData AddNewRod(int id, int count)
        {
            ExchangeItemData itemRodExchangePiece = new ExchangeItemData();
            for (int i = 0; i < count; i++)
            {
                if (rodData.ContainsKey(id))
                {
                    RodData _rodData = _tables.TbRodData.GetOrDefault(id);
                    if (_rodData != null)
                    {
                        RodAscend rodAscend = _tables.TbRodAscend.GetOrDefault(_rodData.AscendID);
                        if (rodAscend != null)
                        {
                            itemRodExchangePiece.exchangeId = rodAscend.FragmentID;
                            itemRodExchangePiece.exchangeCount += rodAscend.DuplicationTransformed;
                            AddRodPiece(rodAscend.FragmentID, rodAscend.DuplicationTransformed);
                        }
                    }
                }
                else
                {
                    GContext.container.Resolve<PlayerData>().AddNewRod(id);
                    rodData.Add(id, 0);
                    PlayFabMgr.Instance.UpdateUserDataValue("RodData", JsonMapper.ToJson(rodData));
                    //鱼竿红点数据修改
                    RedPointManager.Instance.SetRedPointState(RedPointName.Home_Rod, true);
                }
            }
            return itemRodExchangePiece;
        }
        public bool GetRodCanUp()
        {
            return RodCanUp;
        }
        public bool GetRodCanUpLevel()
        {
            return RodCanUpLevel;
        }
        public int GetRodAllCount()
        {
            int count = 0;
            foreach (var item in rodData)
            {
                if (item.Key < 10000000)
                {
                    count++;
                }
            }
            return count;
        }
        public int GetRoodAllLevel()
        {
            int count = 0;
            foreach (var item in rodLevelData)
            {
                count += item.Value;
            }
            return count;
        }
        int GetRodAllStar()
        {
            int count = 0;
            foreach (var item in rodData)
            {
                if (item.Key < 10000000)
                {
                    count += item.Value;
                }
            }
            return count;
        }
        public int GetRodAllScore()
        {
            int points1 = _tables.TbRodEarnPoints[1].Points;
            int points2 = _tables.TbRodEarnPoints[2].Points;
            int allLevel = GetRoodAllLevel();
            int allStar = GetRodAllStar();
            int score = allStar * points2 + allLevel * points1;
            return score;
        }

        public float GetRodAscendStats()
        {
            int allScore = GetRodAllScore();
            var dataList = GContext.container.Resolve<Tables>().TbRodLevelupStats.DataList;
            float PointBonus = 0;
            for (int i = 0; i < dataList.Count; i++)
            {
                if (allScore < dataList[i].Count)
                {
                    break;
                }
                PointBonus += dataList[i].CashBonus;
            }
            return PointBonus;
        }

        public void RodLevelUp(int id, int count)
        {
            GContext.Publish(new ConditionTypeEvent { type = ConditionType.UpgradeRodTimes, count = 1 });
            if (rodLevelData.TryGetValue(id, out int level))
            {
                rodLevelData[id]++;
            }
            else
            {
                rodLevelData[id] = 1;
            }
#if AGG
            using (var e = GEvent.GameEvent("item_change", gaSend: true))
            {
                e.AddContent("item_id", 1003)
                 .AddContent("state_info", "cost")
                 .AddContent("change_num", count);
            }
            using (var e = GEvent.GameEvent("rod_upgrade"))
            {
                e.AddContent("rod_id", id)
                 .AddContent("rod_level", GetRodLevel(id))
                 .AddContent("resin_consume", count)
                 .AddContent("rod_star", rodData[id])
                 .AddContent("rod_chips_consume", 0);
            }
#endif
            PlayFabMgr.Instance.UpdateUserDataValue("RodLevelData", JsonMapper.ToJson(rodLevelData));

            GContext.container.Resolve<PlayerData>().SetPearl(GContext.container.Resolve<PlayerData>().pearl - count);
        }
        public int GetRodLevel(int id)
        {
            return rodLevelData.TryGetValue(id, out int level) ? level : 0;
        }
        public bool CheckUpgrade(RodAscend _rodAscend)
        {
            int fragment = GetRodPiece(_rodAscend.FragmentID);
            int requireNum = _rodAscend.AscentTransformed[0];
            return fragment >= requireNum;
        }
        public bool CheckUpgrade(RodData data)
        {
            int rodId = data.ID;
            RodAscend _rodAscend = _tables.TbRodAscend.GetOrDefault(data.AscendID);
            bool isLock = NotRod(rodId);
            int star = isLock ? -1 : GetRodPiece(rodId);

            bool isMax = star >= _rodAscend.MaxAscent;
            if (isLock || isMax)
            {
                return false;
            }
            int fragment = GetRodPiece(_rodAscend.FragmentID);
            int requireNum = _rodAscend.AscentTransformed[star + 1];
            if (fragment >= requireNum)
            {
                return true;
            }

            ///还有判断通用碎片
            int rquiredFragments = requireNum - fragment;
            fragment = 0;
            RodFragmentExchange rodFragmentExchange = _tables.TbRodFragmentExchange.GetOrDefault(data.Quality);
            if (rodFragmentExchange != null)
            {
                rquiredFragments *= rodFragmentExchange.ExchangeRate;
                fragment = GetRodPiece(rodFragmentExchange.GeneralFragmentID);
            }
            return fragment >= rquiredFragments;

        }


        public void AddRodPiece(int id, int count)
        {
            if (rodData.ContainsKey(id))
            {
                rodData[id] += count;
            }
            else
            {
                rodData.Add(id, count);
            }
            //鱼竿红点数据修改
            CheckRodRedPointUp();
            PlayFabMgr.Instance.UpdateUserDataValue("RodData", JsonMapper.ToJson(rodData));
        }

        public int GetRodPiece(int id)
        {
            return rodData.ContainsKey(id) ? rodData[id] : 0;
        }

        public void GMSetLvAll(int lv)
        {
            if (lv <= 0)
            {
                return;
            }
            List<RodData> rodTBData = _tables.TbRodData.DataList;
            for (int i = 0; i < rodTBData.Count; i++)
            {
                RodData rodData = rodTBData[i];
                rodLevelData[rodData.ID] = lv;
                RodLevelup rodLevelup = _tables.TbRodLevelup.GetOrDefault(rodData.LevelupID);
                if (lv >= rodLevelup.MaxLevel)
                {
                    rodLevelData[rodData.ID] = rodLevelup.MaxLevel - 1;
                }
                else
                {
                    rodLevelData[rodData.ID] = lv;
                }
            }

            PlayFabMgr.Instance.UpdateUserDataValue("RodData", JsonMapper.ToJson(rodData));
        }

        public void GMSetStarAll(int lv)
        {
            if (lv <= 0)
            {
                return;
            }
            List<RodData> rodTBData = _tables.TbRodData.DataList;
            for (int i = 0; i < rodTBData.Count; i++)
            {
                RodData _rodData = rodTBData[i];

                RodAscend rodAscend = _tables.TbRodAscend.GetOrDefault(_rodData.AscendID);

                if (lv >= rodAscend.AscentTransformed.Count)
                {
                    rodData[_rodData.ID] = rodAscend.AscentTransformed.Count - 1;
                }
                else
                {
                    rodData[_rodData.ID] = lv;
                }
            }

            PlayFabMgr.Instance.UpdateUserDataValue("RodData", JsonMapper.ToJson(rodData));
        }

        public void GMAddAllFishMastery(bool all = false)
        {
            FishData fishTBData;
            cfg.FishCard cardTBData;
            if (!all)
            {
                MapData mapTBData = _tables.TbMapData.DataMap[GContext.container.Resolve<PlayerData>().currentMapId];
                List<int> fishList = mapTBData.FishList;
                Dictionary<int, FishWeightData> _fishData =
                    mapFishData.TryGetValue(GContext.container.Resolve<PlayerData>().currentMapId, out var v)
                        ? v
                        : new Dictionary<int, FishWeightData>();
                foreach (var fish in fishList)
                {
                    fishTBData = _tables.TbFishData.DataMap[fish];
                    cardTBData = _tables.TbFishCard.DataMap[fishTBData.FishCardID];
                    FishWeightData fishWeightData = new FishWeightData();

                    if (fishData.ContainsKey(fishTBData.ID))
                    {
                        fishWeightData = fishData[fishTBData.ID];
                    }
                    else
                    {
                        fishData[fishTBData.ID] = fishWeightData;
                        if (mapFishData.ContainsKey(mapTBData.ID))
                        {
                            mapFishData[mapTBData.ID][fishTBData.ID] = fishWeightData;
                        }
                        else
                        {
                            mapFishData[mapTBData.ID] = new Dictionary<int, FishWeightData>
                            {
                                [fishTBData.ID] = fishWeightData
                            };
                        }

                    }

                    if (fishWeightData.MaxG <= 0)
                    {
                        fishWeightData.MaxG = 1;
                    }
                    if (fishWeightData.Level < cardTBData.MaxLevel)
                    {
                        fishWeightData.Level += 1;
                    }

                    fishWeightData.TotalCard =
                        Math.Max(cardTBData.CardsRequiredList[fishWeightData.Level - 1],
                            fishWeightData.TotalCard);
                    fishCardData[fishTBData.FishCardID] = fishWeightData.TotalCard;
                }

                MapNewUpdateUserDataValue(GContext.container.Resolve<PlayerData>().currentMapId, _fishData);
            }
            else
            {
                Dictionary<int, MapData> mapTBData = _tables.TbMapData.DataMap;
                foreach (var map in mapTBData)
                {
                    List<int> fishList = map.Value.FishList;
                    Dictionary<int, FishWeightData> _fishData = mapFishData.TryGetValue(map.Key, out var v)
                        ? v
                        : new Dictionary<int, FishWeightData>();
                    foreach (var fish in fishList)
                    {
                        fishTBData = _tables.TbFishData.DataMap[fish];
                        cardTBData = _tables.TbFishCard.DataMap[fishTBData.FishCardID];
                        FishWeightData fishWeightData = new FishWeightData();
                        if (fishData.ContainsKey(fishTBData.ID))
                        {
                            fishWeightData = fishData[fishTBData.ID];
                        }
                        else
                        {
                            fishData[fishTBData.ID] = fishWeightData;
                            if (mapFishData.ContainsKey(map.Key))
                            {
                                mapFishData[map.Key][fishTBData.ID] = fishWeightData;
                            }
                            else
                            {
                                mapFishData[map.Key] = new Dictionary<int, FishWeightData>
                                {
                                    [fishTBData.ID] = fishWeightData
                                };
                            }

                        }

                        if (fishWeightData.MaxG <= 0)
                        {
                            fishWeightData.MaxG = 1;
                        }
                        if (fishWeightData.Level < cardTBData.MaxLevel)
                        {
                            fishWeightData.Level += 1;
                        }

                        fishWeightData.TotalCard =
                            Math.Max(cardTBData.CardsRequiredList[fishWeightData.Level - 1],
                                fishWeightData.TotalCard);
                        fishCardData[fishTBData.FishCardID] = fishWeightData.TotalCard;
                    }

                    MapNewUpdateUserDataValue(map.Key, _fishData);
                }
            }
        }

        public void GMAddAllFishMastery1(bool all = false)
        {
            FishData fishTBData;
            cfg.FishCard masteryTBData;

            if (!all)
            {
                MapData mapTBData = _tables.TbMapData.DataMap[GContext.container.Resolve<PlayerData>().currentMapId];
                List<int> fishList = mapTBData.FishList;

                foreach (var fish in fishList)
                {
                    fishTBData = _tables.TbFishData.DataMap[fish];
                    masteryTBData = _tables.TbFishCard.DataMap[fishTBData.FishCardID];
                    FishWeightData fishWeightData = new FishWeightData();
                    if (fishData.ContainsKey(fishTBData.ID))
                    {
                        fishWeightData = fishData[fishTBData.ID];
                    }
                    else
                    {
                        fishData[fishTBData.ID] = fishWeightData;
                        if (mapFishData.ContainsKey(mapTBData.ID))
                        {
                            mapFishData[mapTBData.ID][fishTBData.ID] = fishWeightData;
                        }
                        else
                        {
                            mapFishData[mapTBData.ID] = new Dictionary<int, FishWeightData>
                            {
                                [fishTBData.ID] = fishWeightData
                            };
                        }

                    }
                    fishWeightData.TotalCard = masteryTBData.CardsRequiredList[masteryTBData.MaxLevel - 1];
                    fishWeightData.Level = masteryTBData.MaxLevel;
                    fishCardData[fishTBData.FishCardID] = fishWeightData.TotalCard;
                }
                int mapID = GContext.container.Resolve<PlayerData>().currentMapId;
                MapNewUpdateUserDataValue(mapID, mapFishData[mapID]);
            }
            else
            {
                Dictionary<int, MapData> mapTBData = _tables.TbMapData.DataMap;
                foreach (var map in mapTBData)
                {
                    List<int> fishList = map.Value.FishList;

                    foreach (var fish in fishList)
                    {
                        fishTBData = _tables.TbFishData.DataMap[fish];
                        masteryTBData = _tables.TbFishCard.DataMap[fishTBData.FishCardID];
                        FishWeightData fishWeightData = new FishWeightData();
                        if (fishData.ContainsKey(fishTBData.ID))
                        {
                            fishWeightData = fishData[fishTBData.ID];
                        }
                        else
                        {
                            fishData[fishTBData.ID] = fishWeightData;
                            if (mapFishData.ContainsKey(map.Key))
                            {
                                mapFishData[map.Key][fishTBData.ID] = fishWeightData;
                            }
                            else
                            {
                                mapFishData[map.Key] = new Dictionary<int, FishWeightData>
                                {
                                    [fishTBData.ID] = fishWeightData
                                };
                            }

                        }

                        fishWeightData.TotalCard = masteryTBData.CardsRequiredList[masteryTBData.MaxLevel - 1];
                        fishWeightData.Level = masteryTBData.MaxLevel;
                        fishCardData[fishTBData.FishCardID] = fishWeightData.TotalCard;
                    }
                    MapNewUpdateUserDataValue(map.Key, mapFishData[map.Key]);
                }
            }

        }

        public bool NotRod(int id)
        {
            return !rodData.ContainsKey(id);
        }

        public void SetFishAllData(int key, Dictionary<int, FishWeightData> mapData)
        {
            Dictionary<int, FishWeightData> mapDataNew = new Dictionary<int, FishWeightData>();
            foreach (var fishWeightData in mapData)
            {

                FishData _fish = _tables.TbFishData.GetOrDefault(fishWeightData.Key);
                if (_fish != null)
                {
                    if (_fish.AreaID != key)
                    {
                        Debug.Log("fishWeightData.AreaID   " + fishWeightData.Key + "   " + key);

                        continue;
                    }
                    FishWeightData newData = new FishWeightData
                    {
                        Level = fishWeightData.Value.Level,
                        MaxG = fishWeightData.Value.MaxG,
                        TotalCard = fishWeightData.Value.TotalCard,
                        TotalNum = fishWeightData.Value.TotalNum,
                        NewFish = fishWeightData.Value.NewFish
                    };

                    //修正最大重量,过一段时间删除
                    if (_fish.Quality <= 5)
                    {
                        newData.MaxG = FishMaxG(_fish, newData.Level, newData.MaxG);
                    }
                    //修正最大重量

                    mapDataNew.Add(_fish.ID, newData);
                    fishData[_fish.ID] = newData;
                    if (newData.Level > 0)
                    {
                        cfg.FishCard fishCard = _tables.TbFishCard[_fish.FishCardID];
                        if (newData.Level > fishCard.MaxLevel)
                        {
                            newData.Level = fishCard.MaxLevel;
                        }
                        int startWeight = fishCard.CardsRequiredList[newData.Level - 1];
                        if (startWeight > newData.TotalCard)
                        {
                            newData.TotalCard = startWeight;
                        }
                    }
                    fishCardData[_fish.FishCardID] = newData.TotalCard;
                }
            }
            mapFishData[key] = mapDataNew;
        }

        public void SetDataLevel(int id)
        {
            if (fishData.ContainsKey(id))
            {
                fishData[id].Level++;
                SetFishData(id, fishData[id]);
            }
        }
        public void SetDataLevel(int id, int lv)
        {
            if (fishData.ContainsKey(id))
            {
                fishData[id].Level = lv;
                SetFishData(id, fishData[id]);
            }
        }
        public void UpDateLevel(int id)
        {
            SetDataLevel(id);
            //鱼卡战令
            // GContext.container.Resolve<MiniBattlePassDataProvider>().UpdateTaskData(MiniBattlePassType.Fishcard, 1);
            //GContext.Publish(new ConditionTypeEvent(ConditionType.FishCardLevelUp, 1));
#if AGG
            int allLv = GetAllLevel();
            GEvent.SetProp("fishcard_level", allLv);
            GEvent.SetUserProp("fishcard_level", allLv);
            using (var e = GEvent.GameEvent("fishcard_upgrade"))
            {
                e.AddContent("level_count", 1);
            }

#endif
        }

        public void SetWeight(int fishId, float weight)
        {
            //获取鱼重量记录为g
            GContext.Publish(new ConditionTypeEvent(ConditionType.GetFishWeight, (int)(weight * 1000)));
            CheckFishData(fishId);
            if (fishData[fishId].MaxG < weight)
            {
                fishData[fishId].MaxG = weight;
                SetFishData(fishId, fishData[fishId]);
            }
            GContext.Publish(new ConditionTypeEvent(ConditionType.GetFishID, fishId));
        }

        public ExchangeItemData AddTotalCard(int id, int totalCard)
        {
            ExchangeItemData exchangeItemData = null;
            GContext.Publish(new ConditionTypeEvent { type = ConditionType.CollectFishCardCount, count = totalCard });
            if (fishCardData.ContainsKey(id))
            {
                fishCardData[id] += totalCard;
            }
            else
            {
                fishCardData[id] = totalCard;
            }

            var cardData = _tables.TbFishCard.DataMap[id];
            int fishId = cardData.FishID;
            CheckFishData(fishId);
            fishData[fishId].TotalCard += totalCard;

            int cardCount = fishCardData[id];
            int allCount = cardData.CardsRequiredList[^1];
            if (cardCount > allCount)
            {
                int extra = cardCount - allCount;
                fishCardData[id] = allCount;
                fishData[fishId].TotalCard = allCount;
                //鱼卡转换道具
                var dropExchange = _tables.TbFishCardExchange.GetOrDefault(cardData.Quality);
                if (dropExchange != null)
                {
                    var itemData = GContext.container.Resolve<PlayerItemData>().GetItemDataOne(dropExchange.DropID);
                    itemData.count *= extra;
                    GContext.container.Resolve<PlayerItemData>().AddItemCount(itemData.id, itemData.count, null);
                    exchangeItemData = new ExchangeItemData
                    {
                        exchangeId = itemData.id,
                        curCount = itemData.curCount,
                        exchangeCount = Mathf.RoundToInt(itemData.count)
                    };
                }
            }
            SetFishData(fishId, fishData[fishId]);
            return exchangeItemData;
        }
        void CheckFishData(int fishId)
        {
            if (!fishData.ContainsKey(fishId))
            {
                fishData.Add(fishId, new FishWeightData() { NewFish = true });
            }
        }
        public void SetGetFishCount(int fishId)
        {
            int count = GContext.container.Resolve<PlayerData>().GetMagnification();
            CheckFishData(fishId);
            fishData[fishId].TotalNum += count;
        }
        public int GetCardDataProficiency(int id)
        {
            if (fishCardData.ContainsKey(id))
            {
                return fishCardData[id];
            }
            else
            {
                return 0;
            }
        }

        public bool GetFishCanLevel()
        {
            var dataList = _tables.TbMapData.DataList;
            int count = dataList.Count;
            int levelRequired = 0;
            for (int i = 0; i < count; i++)
            {
                if (i > 0)
                {
                    levelRequired = dataList[i - 1].LevelRequired;
                }
                if (GContext.container.Resolve<PlayerData>().lv >= levelRequired)
                {
                    if (GetMapRedCount(dataList[i].FishList) > 0)
                    {
                        return true;
                    }
                }
                else
                {
                    break;
                }
            }
            return false;
        }
        public List<int> GetFishCardIdsCanLevelUpAll()
        {
            var dataList = _tables.TbMapData.DataList;
            int count = dataList.Count;
            int levelRequired = 0;
            var fishCardIds = new List<int>();
            for (int i = 0; i < count; i++)
            {
                if (i > 0)
                {
                    levelRequired = dataList[i - 1].LevelRequired;
                }
                if (GContext.container.Resolve<PlayerData>().lv >= levelRequired)
                {
                    var fishIds = dataList[i].FishList;
                    foreach (var id in fishIds)
                    {
                        var fishCard = _tables.TbFishCard[_tables.TbFishData.DataMap[id].FishCardID];
                        int level = GetDataLevel(id);
                        if (level < fishCard.MaxLevel && GetCardDataProficiency(fishCard.ID) >= fishCard.CardsRequiredList[level])
                        {
                            fishCardIds.Add(fishCard.ID);
                        }
                    }
                }
                else
                {
                    break;
                }
            }
            return fishCardIds;
        }
        public void AutoUpgradeFishCardAll()
        {
            int level;
            int fishId;
            Dictionary<int, int> cardData = new Dictionary<int, int>(fishCardData);
            int allUpLevel = 0;
            foreach (var fishData in cardData)
            {
                var fishCard = _tables.TbFishCard.GetOrDefault(fishData.Key);
                if (fishCard == null)
                {
                    Debug.LogError($"FishCard not found for ID: {fishData.Key}");
                    continue;
                }
                fishId = fishCard.FishID;
                level = GetDataLevel(fishId);
                var cardsRequiredList = fishCard.CardsRequiredList;
                var proficiency = GetCardDataProficiency(fishCard.ID);
                int newLevel = level;
                for (int i = level; i < cardsRequiredList.Count; i++)
                {
                    if (proficiency >= cardsRequiredList[i])
                    {
                        newLevel = i + 1;
                    }
                    else
                    {
                        break;
                    }
                }
                if (newLevel > level)
                {
                    SetDataLevel(fishId, newLevel);
                    allUpLevel += newLevel - level;
                }
            }
            //GContext.Publish(new ConditionTypeEvent(ConditionType.FishCardLevelUp, allUpLevel));
            // GContext.container.Resolve<MiniBattlePassDataProvider>().UpdateTaskData(MiniBattlePassType.Fishcard, allUpLevel);

#if AGG
            int lv = GetAllLevel();
            GEvent.SetProp("fishcard_level", lv);
            GEvent.SetUserProp("fishcard_level", lv);
            using (var e = GEvent.GameEvent("fishcard_upgrade"))
            {
                e.AddContent("level_count", allUpLevel);
            }

#endif
        }


        public bool IsNewFish(int id)
        {
            if (fishData.ContainsKey(id))
            {
                return fishData[id].MaxG < 0.001f;
            }
            else
            {
                return true;
            }
        }
        public int GetDataLevel(int id)
        {
            if (fishData.ContainsKey(id))
            {
                return fishData[id].Level;
            }
            else
            {
                return 0;
            }
        }
        public int GetAllLevel()
        {
            int level = 0;
            foreach (var fish in fishData)
            {
                level += fish.Value.Level;
            }

            return level;
        }

        public float GetDataMaxWeight(int id)
        {
            if (fishData.ContainsKey(id))
            {
                return fishData[id].MaxG;
            }
            else
            {
                return 0;
            }
        }

        public bool GetDataNewFish(int id)
        {
            if (fishData.ContainsKey(id))
            {
                return fishData[id].NewFish;
            }
            else
            {
                return true;
            }
        }

        public void SetDataNewFish(int id)
        {
            if (!fishData.ContainsKey(id) || !fishData[id].NewFish)
            {
                return;
            }

            if (fishData.ContainsKey(id))
            {
                fishData[id].NewFish = false;
            }

            SetFishData(id, fishData[id]);
        }

        void SetFishData(int id, FishWeightData data)
        {
            int mapID = _tables.TbFishData.GetOrDefault(id).AreaID;
            if (mapFishData.ContainsKey(mapID))
            {
                mapFishData[mapID][id] = data;
            }
            else
            {
                mapFishData[mapID] = new Dictionary<int, FishWeightData>
                {
                    [id] = data
                };
            }
            MapNewUpdateUserDataValue(mapID, mapFishData[mapID]);
        }
        void MapNewUpdateUserDataValue(int mapID, Dictionary<int, FishWeightData> keyValuePairs)
        {
            Dictionary<int, string> mapData = keyValuePairs.ToDictionary(_ => _.Key, _ => _.Value.Serialize());
            PlayFabMgr.Instance.UpdateUserDataValue($"Map_5_{mapID}", JsonMapper.ToJson(mapData));
        }
        public int GetFishLevelByMap(int mapId)
        {
            int level = 0;
            if (mapFishData.ContainsKey(mapId))
            {
                Dictionary<int, FishWeightData> keyValuePairs = mapFishData[mapId];
                foreach (var fish in keyValuePairs)
                {
                    level += fish.Value.Level;
                }
            }
            return level;
        }
        public void SetMapRed()
        {
            if (!IsOpenMap)
            {
                RedPointManager.Instance.SetRedPointState(RedPointName.Home_Map, false);
                return;
            }
            int allCount = 0;
            var dataList = _tables.TbMapData.DataList;
            int count = dataList.Count;
            int levelRequired = 0;
            for (int i = 0; i < count; i++)
            {
                if (i > 0)
                {
                    levelRequired = dataList[i - 1].LevelRequired;
                }
                if (GContext.container.Resolve<PlayerData>().lv >= levelRequired)
                {
                    allCount += GetMapRedCount(dataList[i].FishList);
                    if (allCount > 99)
                    {
                        break;
                    }
                }
                else
                {
                    break;
                }
            }
            RedPointManager.Instance.SetRedPointState(RedPointName.Home_Map, allCount > 0, allCount);
        }
        int GetMapRedCount(List<int> fishList)
        {
            int count = 0;
            for (int i = 0; i < fishList.Count; i++)
            {
                var data = _tables.TbFishData.GetOrDefault(fishList[i]);
                if (data == null)
                {
                    continue;
                }
                var fishCard = _tables.TbFishCard.GetOrDefault(data.FishCardID);
                if (fishCard == null)
                {
                    continue;
                }
                var curProficiency = GetCardDataProficiency(data.FishCardID);
                var level = GetDataLevel(data.ID);
                for (int j = level; j < fishCard.MaxLevel; j++)
                {
                    if (curProficiency >= fishCard.CardsRequiredList[j])
                    {
                        count++;
                    }
                    else
                    {
                        break;
                    }
                }
            }
            return count;
        }
        public bool GetMapRed(List<int> fishList)
        {
            for (int i = 0; i < fishList.Count; i++)
            {
                var data = _tables.TbFishData.GetOrDefault(fishList[i]);
                if (data == null)
                {
                    continue;
                }
                int curProficiency = GetCardDataProficiency(data.FishCardID);
                var level = GetDataLevel(data.ID);
                var fishCard = _tables.TbFishCard.GetOrDefault(data.FishCardID);
                if (fishCard == null)
                {
                    continue;
                }

                if (level < fishCard.MaxLevel)
                {
                    int endWeight = fishCard.CardsRequiredList[level];
                    if (curProficiency >= endWeight)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        //实际数值
        public float GetAscendValue(float _rodDataValue, List<float> _valueRange)
        {
            if (_valueRange.Count == 1)
            {
                return _rodDataValue * _valueRange[0];
            }
            _rodDataValue = Mathf.Clamp(_rodDataValue, _valueRange[2], _valueRange[3]);
            return (_rodDataValue - _valueRange[2]) / (_valueRange[3] - _valueRange[2]) * (_valueRange[1] - _valueRange[0]) + _valueRange[0];
        }

        //游弋鱼
        public int GetFishSwimToMap(int id)
        {
            if (fishSwimToMap.TryGetValue(id, out var fishId))
            {
                return fishId;
            }
            return -1;
        }

        public void SetFishSwimToMap(int id, int fishId)
        {
            if (fishId != 0)
            {
                fishSwimToMapCount[id] = 0;
                PlayFabMgr.Instance.UpdateUserDataValue("FishSwimToMapCount", JsonMapper.ToJson(fishSwimToMapCount));
            }
            fishSwimToMap[id] = fishId;
            PlayFabMgr.Instance.UpdateUserDataValue("FishSwimToMap", JsonMapper.ToJson(fishSwimToMap));
        }
        public void SetFishSwimToMapCount(int id, int count)
        {
            if (fishSwimToMapCount.ContainsKey(id))
            {
                fishSwimToMapCount[id]++;
                if (fishSwimToMapCount[id] >= count)
                {
                    SetFishSwimToMap(id, 0);
                }
                PlayFabMgr.Instance.UpdateUserDataValue("FishSwimToMapCount", JsonMapper.ToJson(fishSwimToMapCount));
            }
        }
        //===========================鱼图鉴===========================
        #region 鱼图鉴相关
        public void InitMapProgress(string value)
        {
            mapProgress = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<int, int>>(value);
        }
        public int GetMapProgress(int mapID)
        {
            if (mapProgress.TryGetValue(mapID, out int progress))
            {
                MapData mapData = _tables.TbMapData.GetOrDefault(mapID);
                int AllPTS = GetAllPTSByMap(mapData.ID);
                var pointsRequire = mapData.PointsRequire;
                for (int i = 0; i < pointsRequire.Count; i++)
                {
                    if (i >= progress)
                    {
                        break;
                    }
                    else if (AllPTS < pointsRequire[i])
                    {
                        mapProgress[mapID] = i;
                        return i;
                    }
                }
                return progress;
            }
            else
            {
                return 0;
            }
        }
        public void GetMapProgressReward(MapData mapData)
        {
            int mapID = mapData.ID;
            int AllPTS = GetAllPTSByMap(mapData.ID);
            var pointsRequires = mapData.PointsRequire;
            mapProgress.TryGetValue(mapID, out int progress);
            mapProgress[mapID] = pointsRequires.Count;
            List<int> dorpList = new List<int>();
            for (int i = progress; i < pointsRequires.Count; i++)
            {
                if (AllPTS < pointsRequires[i])
                {
                    mapProgress[mapID] = i;
                }
                else
                {
                    int dorpID = mapData.PointsReward[i];
                    int pointsRequire = mapData.PointsRequire[i];
                    dorpList.Add(dorpID);
#if AGG
                    using (var e = GEvent.GameEvent("map_points_reward"))
                    {
                        float averageLevel = GetFishLevelByMap(mapID);
                        averageLevel /= mapData.FishList.Count;
                        e.AddContent("map_id", mapID)
                        .AddContent("points", pointsRequire)
                        .AddContent("drop_id", dorpID)
                        .AddContent("current_map_fishcard_lv", averageLevel)
                        ;
                    }
#endif
                }
            }

            GContext.container.Resolve<PlayerItemData>().AddItemByDropList(dorpList, null);
            PlayFabMgr.Instance.UpdateUserDataValue("MapProgress", Newtonsoft.Json.JsonConvert.SerializeObject(mapProgress));
        }

        public int GetAllPTSByMap(int mapID)
        {
            if (mapFishData.TryGetValue(mapID, out Dictionary<int, FishWeightData> weightData))
            {
                int allPts = 0;
                foreach (var item in weightData)
                {
                    int id = item.Key;
                    float MaxG = item.Value.MaxG;
                    FishData fishData = _tables.TbFishData.GetOrDefault(id);
                    if (fishData != null)
                    {
                        DropPackageList dropPackageList = _tables.TbDrop[fishData.DropID].DropList;
                        float proficiency = dropPackageList.DropCountList[0] * MaxG / fishData.BaseWeight;
                        allPts += (int)(proficiency);
                    }
                }
                return allPts;
            }
            else
            {
                return 0;
            }
        }
        public bool PTSRed()
        {
            if (GContext.container.Resolve<PlayerData>().OpenGrade)
            {
                var DataMap = GContext.container.Resolve<Tables>().TbMapData.DataMap;
                foreach (var mapData in DataMap.Values)
                {
                    int progress = GetMapProgress(mapData.ID);
                    var pointsRequire = mapData.PointsRequire;
                    if (progress < pointsRequire.Count && GetAllPTSByMap(mapData.ID) >= pointsRequire[progress])
                    {
                        RedPointManager.Instance.SetRedPointState("menu.achieve", true);

                        return true;
                    }
                }
            }
            RedPointManager.Instance.SetRedPointState("menu.achieve", false);
            return false;
        }
        #endregion
        //===========================鱼图鉴===========================
        public static void SetFishIcon(Image icon_fish, Item item)
        {
            IUIService uIService = GContext.container.Resolve<IUIService>();
            string spriteName = "fishicon_empty_02";
            if (item.Quality < 3)
            {
                spriteName = "fishicon_empty_01";
            }
            else if (item.Quality > 3)
            {
                spriteName = "fishicon_empty_03";
            }
            icon_fish.sprite = uIService.GetSprite(spriteName);
            uIService.SetImageSprite(icon_fish, item.Icon);//鱼头像
        }
    }
}

public struct ExchangeFishCount
{
    public ExchangeFishCount(int fishCount)
    {
        FishCount = fishCount;
    }
    public int FishCount;
}