using System.Collections.Generic;
using CodeStage.AntiCheat.ObscuredTypes;
using asap.core;
using LitJson;
using System;
using System.Linq;
using cfg;
using DataCenter;
using game;
using HexGrid;
using Newtonsoft.Json;
using Script.RuntimeScript;
using UnityEngine;

namespace GameCore
{
    public class PlayerData
    {
        private cfg.Tables _tables;
        MMTService _MMService;
        public PlayerData(cfg.Tables tables, MMTService mmService)
        {
            this._tables = tables;
            _MMService = mmService;
        }
        public const string Gold = "Gold";
        /// <summary>
        /// "Diamond"==>"Pearl"(不改名是因为数据已经通过Diamond键存储到云端了)
        /// </summary>
        public const string Pearl = "Diamond";
        public const string RodLevel = "RodLevel";
        public const string WeightScore = "WeightScore";
        public const string Diamond = "DiamondTrue";
        Dictionary<string, string> NewPlayerDataDic = new Dictionary<string, string>();
        public IReadOnlyDictionary<string, string> PlayerDataDic => NewPlayerDataDic;
        public ObscuredInt lv { get; set; }
        public ObscuredInt vip { get; private set; }
        public ObscuredInt vipScore { get; private set; }
        public ObscuredInt vipAllScore { get; private set; }
        #region 付费积分
        public int initPackPoints = 0;
        public int PriceLv { get; private set; }
        //付费等级=f1(vip积分,地区积分)+f2(活跃积分)
        public int AllPackPoints => initPackPoints + vipAllScore;
        public PriceLevel priceLevel;
        #endregion 付费积分
        private ObscuredInt energy;
        int energyRM;
        public ObscuredULong gold { get; private set; }
        ulong goldRM;
        public ObscuredInt pearl { get; private set; }
        public ObscuredInt diamond { get; private set; }

        public ObscuredInt equipRodID = 10001;
        public ObscuredInt magnification;
        public ObscuredInt seasonId = 0;
        public ObscuredInt rewardNewMap = 0;
        bool IsOpenAppraise = false;
        ObscuredInt _currentMapId = 0;
        public string InfiniteBuildingData = "0";
        public string InfiniteBuildingLevel => InfiniteBuildingData.Split(',')[0];
        public ObscuredInt currentMapId
        {
            set { _currentMapId = value; }
            get
            {
                if (_currentMapId == 0 || !_tables.TbMapData.DataMap.ContainsKey(_currentMapId))
                {
                    _currentMapId = _tables.TbMapData.DataList[0].ID;
                }
                //if (_TestService.TestMapIDs != null)
                //{
                //    var ab = _TestService.TestMapIDs.FirstOrDefault(a => a.OldID == _currentMapId);
                //    return ab != null ? ab.NewID : _currentMapId;
                //}
                return _currentMapId;
            }
        }
        ObscuredInt _lastMapId = 0;
        public ObscuredInt lastMapId
        {
            set { _lastMapId = value; }
            get
            {
                if (_lastMapId == 0)
                {
                    _lastMapId = _tables.TbMapData.DataList[0].ID;
                }
                //if (_TestService.TestMapIDs != null)
                //{
                //    var ab = _TestService.TestMapIDs.FirstOrDefault(a => a.OldID == _lastMapId);
                //    return ab != null ? ab.NewID : _lastMapId;
                //}
                return _lastMapId;
            }
        }
        public List<int> newRodList = new List<int>();

        public List<int> showNewRodList = new List<int>();

        bool addShowNewRod = true;

        public float benefitsCashMag { get; private set; }
        public float benefitsCashMagLimited { get; private set; }
        public int benefitsEnergyLimit { get; private set; }
        public int benefitsEnergyRecover { get; private set; }
        public float benefitsEventFishCashMag { get; private set; }
        public float benefitsEventFishDamage { get; private set; }
        public int benefitsAquariumLimit { get; private set; }
        public float benefitsAquariumCashMag { get; private set; }
        public List<int> benefitsLevel;
        public int OpenGradeID = 0;
        public bool OpenGrade = false;
        public int MagnificationCount
        {
            get
            {
                List<EnergyDef> DataList = _tables.TbEnergyDef.DataList;
                var buffTimeData = GContext.container.Resolve<BuffDataCenter>().GetWeelyBuffTimeData<SuperEnergyMag>();
                bool isSuperEnergy = buffTimeData != null;
                for (int i = 0; i < DataList.Count; i++)
                {
                    int demandEnergy = DataList[i].Energy;
                    if (isSuperEnergy)
                    {
                        demandEnergy = DataList[i].FishBuffEnergy;
                    }
                    if (demandEnergy < 0 || Energy < demandEnergy)
                    {
                        return i;
                    }
                }
                return DataList.Count;
            }
        }
        public AccountMM nextAccountData;
        public VipLevel curVipData;
        public bool IsOpenMagnification = false;
        public int GetCurMaxMagnification()
        {
            var buffTimeData = GContext.container.Resolve<BuffDataCenter>().GetWeelyBuffTimeData<SuperEnergyMag>();
            bool isSuperEnergy = buffTimeData != null;
            List<EnergyDef> DataList = _tables.TbEnergyDef.DataList;
            for (int i = DataList.Count - 1; i >= 0; i--)
            {
                int demandEnergy = DataList[i].Energy;
                if (isSuperEnergy)
                {
                    demandEnergy = DataList[i].FishBuffEnergy;
                }
                if (demandEnergy >= 0)
                {
                    if (Energy >= demandEnergy)
                    {
                        return i;
                    }
                }
            }
            return 0;
        }

        /// <summary>
        /// buff 过期
        /// </summary>
        public void CheckSuperEnergyBuff()
        {
            List<EnergyDef> DataList = _tables.TbEnergyDef.DataList;
            for (int i = DataList.Count - 1; i >= 0; i--)
            {
                if (DataList[i].Energy >= 0)
                {
                    if (i < magnification)
                    {
                        magnification = i;
                        SetMagnification();
                    }
                    return;
                }
            }
        }

        public ObscuredInt Energy
        {
            get => energy;
            private set { SetEnergy(value); }
        }
        int RecoverNotificationID = 1002;
        public ObscuredInt MaxEnergy => benefitsEnergyLimit;

        public int EnergyRecover => benefitsEnergyRecover;

        DateTime _lastEnergyRecoveryTime = ZZTimeHelper.UtcNow();

        public void SetEnergy(int count, bool remote = true)
        {
            if (count < 0)
            {
                count = 0;
            }
            if (count < energy)
            {
                energyRM += energy - count;
            }
            energy = count;
            if (energy >= MaxEnergy)
            {
                GContext.container.Resolve<ILocalNotificationService>().ClearNotification(RecoverNotificationID);
            }
            SavePlayerData(remote);
        }
        public int GetEnergyRM()
        {
            return energyRM;
        }
        public void AddGold(ulong count)
        {
            SetGold(gold + count);
        }
        public void SetGold(ulong count)
        {
            if (count < gold)
            {
                goldRM += gold - count;
            }
            gold = count;
            SavePlayerData();
        }

        public void SetPearl(int count)
        {
            if (count < 0)
            {
                count = 0;
            }
            pearl = count;
            SavePlayerData();
            GContext.container.Resolve<PlayerFishData>().CheckAllRodUpLevel();
        }
        public void AddDiamond(int count)
        {
            var newCount = diamond + count;
            if (newCount < 0)
            {
                newCount = 0;
            }
            diamond = newCount;
            if (count < 0)
            {
                GContext.Publish(new ConditionTypeEvent { type = ConditionType.ConsumeDiamondCount, count = -count });
                GContext.Publish(new ResAddEvent(1005));
            }
            SavePlayerData();
        }


        public void SetEquipRodID(int ID)
        {
            equipRodID = ID;
            GContext.container.Resolve<PlayerFishData>().SetRedPoint();
            SavePlayerData();
        }

        public void SetMagnification()
        {
            SavePlayerData();
        }

        public void AddNewMap(int index)
        {
            rewardNewMap |= 1 << index;
        }

        public void RewardNewMap(int index)
        {
            int newMap = 1 << index;
            rewardNewMap &= ~newMap;
            SavePlayerData();
        }

        public bool IsNewMap(int index)
        {
            int newMap = 1 << index;
            return (rewardNewMap & newMap) == newMap;
        }


        public void AddNewRod(int id)
        {
            if (!newRodList.Contains(id))
            {
                newRodList.Add(id);
                PlayFabMgr.Instance.UpdateUserDataValue("NewRodList", JsonMapper.ToJson(newRodList));
                if (addShowNewRod)
                {
                    showNewRodList.Add(id);
                }
            }
        }

        public void StartAddNewRod()
        {
            addShowNewRod = true;
        }

        public void ShowNewRod()
        {
            //addShowNewRod = false;
            if (showNewRodList.Count > 0)
            {
                List<ItemData> itemDatas = new List<ItemData>();
                for (int i = 0; i < showNewRodList.Count; i++)
                {
                    itemDatas.Add(new ItemData { id = showNewRodList[i], count = 1 });
                }
                GContext.Publish(new ShowData(itemDatas, RewardType.NewRod));
                showNewRodList.Clear();
            }
        }

        public void RewardNewRod(int id)
        {
            newRodList.Remove(id);
            PlayFabMgr.Instance.UpdateUserDataValue("NewRodList", JsonMapper.ToJson(newRodList));
            GContext.container.Resolve<PlayerFishData>().SetRedPoint();
        }

        public bool IsNewRod(int id)
        {
            return newRodList.Contains(id);
        }

        public void SetLv(int count)
        {
            int addLevel = count - lv;
            int isRewards = 0;
            string Img = "";
            List<int> DisplaySwitch = null;
            int nextAccountDataID = 0;
            var account = nextAccountData;
            if (lv < nextAccountData.ID && count >= nextAccountData.ID)
            {
                isRewards = nextAccountData.Rewards;
                Img = nextAccountData.Img;
                nextAccountDataID = nextAccountData.ID;
                DisplaySwitch = nextAccountData.DisplaySwitch;
            }
            lv = count;

#if AGG
            GEvent.SetProp("building_times", count);
            GEvent.SetUserProp("building_times", count);
#endif
            GContext.Publish(new ConditionTypeEvent(ConditionType.AccountLevel, addLevel));
            GContext.Publish(new ConditionTypeEvent(ConditionType.ConstructionCount, addLevel));
            OnLvChange();

            if (DisplaySwitch != null)
            {
                var table = GContext.container.Resolve<cfg.Tables>();
                int id;
                Item item;
                for (int i = 0; i < DisplaySwitch.Count; i++)
                {
                    if (DisplaySwitch[i] > 0 && benefitsLevel[i] > 0 && i < benefitsLevel.Count)
                    {
                        id = 12001 + i;
                        item = table.TbItem.GetOrDefault(id);
                        List<ItemData> itemData = new List<ItemData>() { new ItemData { id = id, count = benefitsLevel[i] } };
                        GContext.Publish(new ShowData(itemData, RewardType.BenefitUpgrade));
                    }
                }
            }
            if (!string.IsNullOrEmpty(Img))
            {
                //开启系统
                GContext.Publish(new ShowData(RewardType.FeaturesUnlock, nextAccountDataID));
            }
            if (isRewards != 0)
            {
                var itemData = GContext.container.Resolve<PlayerItemData>().AddItemByDrop(isRewards);
            }
            //if (isRewards != 0 || !string.IsNullOrEmpty(Img))
            //{
            //    CurRewardQCount curRewardQCount = new CurRewardQCount();
            //    GContext.Publish(curRewardQCount);
            //    if (curRewardQCount.count > 0)
            //    {
            //        GContext.container.Resolve<CampData>().curQRewardCount = curRewardQCount.count + 1;
            //    }
            //    else
            //    {
            //        GContext.container.Resolve<CampData>().curQRewardCount = 0;
            //    }
            //}
            //if (GContext.container.Resolve<ClubService>().IsOpenClubJoined)
            {
                GContext.container.Resolve<LeadboardData>().AwaitSetLvData();
            }
        }
        //等级改变的时候

        public void OnLvChange()
        {
            var account = _tables.TBAccount.DataList;
            nextAccountData = account[^1];

            AccountMM curAccountData = null;
            for (int i = 0; i < account.Count; i++)
            {
                if (lv < account[i].ID)
                {
                    nextAccountData = account[i];
                    break;
                }
                else
                {
                    curAccountData = account[i];
                }
            }
            SetBenefits(curAccountData);
            //解锁地图
            int unLockIndex = 0;
            var dataList = _tables.TbMapData.DataList;
            var mapData = dataList[^1];
            int count = dataList.Count;
            for (int i = 0; i < count; i++)
            {
                if (lv < dataList[i].LevelRequired)
                {
                    unLockIndex = i;
                    mapData = dataList[i];
                    break;
                }
            }
            int newMapId = mapData.ID;

            if (lastMapId != newMapId)
            {
                lastMapId = newMapId;
                LoadNewMap();
#if AGG
                using (var e = GEvent.GameEvent("open_new"))
                {
                    e.AddContent("open_type", 1)
                        .AddContent("map_id", lastMapId);

                }
#endif
                if (unLockIndex > 0)
                {
                    GContext.container.Resolve<ClubService>().SendSystemMessage2(unLockIndex);
                    AddNewMap(unLockIndex);
                }
            }
            SavePlayerData();
            GContext.Publish(new OnLvChangeEvent() { lvl = lv });
            AiHelpManager.Instance.Update();
        }
        void SetBenefits(AccountMM curAccountData)
        {
            int levelCashMag = 0;
            int levelCashMagLimited = 0;
            int levelEnergyLimit = 0;
            int levelEnergyRecover = 0;
            int levelEventFishCashMag = 0;
            int levelEventFishDamage = 0;
            int levelAquariumLimit = 0;
            int levelAquariumCashMag = 0;
            if (curAccountData != null)
            {
                levelCashMag = curAccountData.CashMag;
                levelCashMagLimited = curAccountData.CashMagLimited;
                levelEnergyLimit = curAccountData.EnergyLimit;
                levelEnergyRecover = curAccountData.EnergyRecover;
                levelEventFishCashMag = curAccountData.EventFishCashMag;
                levelEventFishDamage = curAccountData.EventFishDamage;
                levelAquariumLimit = curAccountData.AquariumLimit;
                levelAquariumCashMag = curAccountData.AquariumCashMag;
            }
            benefitsLevel = new List<int>
            {
                levelCashMag,
                levelCashMagLimited,
                levelEnergyLimit,
                levelEnergyRecover,
                levelEventFishCashMag,
                levelEventFishDamage,
                levelAquariumLimit,
                levelAquariumCashMag,
            };
            var TbBenefits = _tables.TBBenefits;
            benefitsCashMag = TbBenefits.GetOrDefault(1).BenefitsValue[levelCashMag];
            benefitsCashMagLimited = TbBenefits.GetOrDefault(2).BenefitsValue[levelCashMagLimited];
            benefitsEnergyLimit = Mathf.RoundToInt(TbBenefits.GetOrDefault(3).BenefitsValue[levelEnergyLimit]);
            benefitsEnergyRecover = Mathf.RoundToInt(TbBenefits.GetOrDefault(4).BenefitsValue[levelEnergyRecover]);
            benefitsEventFishCashMag = TbBenefits.GetOrDefault(5).BenefitsValue[levelEventFishCashMag];
            benefitsEventFishDamage = TbBenefits.GetOrDefault(6).BenefitsValue[levelEventFishDamage];
            benefitsAquariumLimit = Mathf.RoundToInt(TbBenefits.GetOrDefault(7).BenefitsValue[levelAquariumLimit]);
            benefitsAquariumCashMag = TbBenefits.GetOrDefault(8).BenefitsValue[levelAquariumCashMag];
        }
        public void LoadNewMap()
        {
            ILoadResourceService loadResourceService = GContext.container.Resolve<ILoadResourceService>();
            var mapData = _tables.TbMapData.GetOrDefault(lastMapId);
            if (mapData != null && mapData.DownloadPkg != null && mapData.DownloadPkg.Count > 0)
            {
                var fishList = _tables.TbAquariumConfig.AquariumSpFishList;
                List<string> strings = new List<string>();
                foreach (var fish in fishList)
                {
                    var item = _tables.TbItem.GetOrDefault(fish);
                    var fishData = _tables.TbFishData.GetOrDefault(item.RedirectID);
                    if (item != null && !string.IsNullOrEmpty(fishData.Fbx))
                    {
                        strings.Add(fishData.Fbx);
                    }
                }
                strings.AddRange(mapData.DownloadPkg);

                loadResourceService.Load(strings);
            }
        }
        public MapData GetCurrentMapData()
        {
            return _tables.TbMapData.GetOrDefault(currentMapId);
        }
        public bool MapIsUnlock(List<string> Param)
        {
            return Param.Contains(lastMapId.ToString());
        }
        public void SetCurrentMapId(int id)
        {
            currentMapId = id;
            SavePlayerData();
        }
        void SetVIP(int count)
        {
            if (vip != count)
            {
                int addLevel = count - vip;
                vip = count;
                curVipData = _tables.TbVipLevel.DataList[vip];
            }
            else
            {
                curVipData = _tables.TbVipLevel.DataList[vip];
            }
#if AGG
                GEvent.SetProp("vip_level", count);
                GEvent.SetUserProp("vip_level", count);
#endif
            SetPriceLv();
#if AGG
            GEvent.SetProp("pay_level", PriceLv);
            GEvent.SetUserProp("pay_level", PriceLv);
#endif
            AiHelpManager.Instance.Update();
        }
        public void AddVIPScore(int count, bool isBuy = false)
        {
            vipAllScore += count;
#if AGG
            using (var e = GEvent.GameEvent("getpoint_vip"))
            {
                e.AddContent("add_count", count).AddContent("all_count", vipAllScore);
            }
#endif
            VipChange();
            SavePlayerData();
        }
        void VipChange()
        {
            int LevelScore = 0;
            //设置vip等级
            var vipData = _tables.TbVipLevel.DataList;
            for (int i = 0; i < vipData.Count; i++)
            {
                LevelScore += vipData[i].LevelScore;
                if (vipAllScore < LevelScore)
                {
                    vipScore = vipAllScore - LevelScore + vipData[i].LevelScore;
                    SetVIP(i);
                    return;
                }
            }
            vipScore = vipAllScore - LevelScore + vipData[^1].LevelScore;
            SetVIP(vipData.Count - 1);
        }
        void SetPriceLv()
        {
            int LevelScore = 0;
            //设置vip等级
            var priceData = _tables.TbPriceLevel.DataList;
            for (int i = 0; i < priceData.Count; i++)
            {
                LevelScore += priceData[i].LevelScore;
                if (AllPackPoints < LevelScore)
                {
                    PriceLv = i;
                    priceLevel = priceData[i];
                    return;
                }
            }
            priceLevel = priceData[^1];
            PriceLv = priceData.Count - 1;
        }
        void InitPackPoints()
        {
            string CountryCode = GContext.container.Resolve<IUserService>().CountryCode;
            initPackPoints = 0;
            if (string.IsNullOrEmpty(CountryCode))
            {
                CountryCode = "COUNTRY";
            }
            CountryPoints countryPoints = _tables.TbCountryPoints.GetOrDefault(CountryCode);
            if (countryPoints == null)
            {
                CountryCode = "COUNTRY";
                countryPoints = _tables.TbCountryPoints.GetOrDefault(CountryCode);
            }
            if (countryPoints != null)
            {
#if UNITY_ANDROID
                initPackPoints = countryPoints.AndroidInitPoints;
#else
                initPackPoints = countryPoints.IosInitPoints;
#endif
            }

            Debug.Log($"CountryCode {CountryCode}");
        }

        public void LoadPlayerData(Dictionary<string, string> userDatas)
        {
            InitPackPoints();
            lv = 1;
            gold = (ulong)_tables.TbGlobalConfig.InitCash;
            vipAllScore = 0;
            energy = _tables.TbGlobalConfig.InitEnergy;
            pearl = _tables.TbGlobalConfig.InitResin;
            magnification = 0;
            equipRodID = _tables.TbGlobalConfig.InitRodID;
            _lastEnergyRecoveryTime = ZZTimeHelper.UtcNow();
            rewardNewMap = 0b1;
            GContext.container.Resolve<PlayerShopData>().InitData(userDatas);
            if (userDatas == null || userDatas.Count < 1)
            {
                GameDebug.Log(
                    "[PlayerData]LoadPlayerData: No player data in User Data, initializing with default values");
            }
            else
            {
                GameDebug.Log("[PlayerData]LoadPlayerData: Load Player data from User Data");
                GContext.container.Resolve<PlayerFishData>().InitData(userDatas);
                GContext.container.Resolve<FishingEventData>().InitData(userDatas);

                GContext.container.Resolve<BuffDataCenter>().InitData(userDatas);

                GContext.container.Resolve<CampDataMM>().InitData(userDatas);

                var etor = userDatas.GetEnumerator();

                while (etor.MoveNext())
                {
                    var data_key = etor.Current.Key;
                    var data_value = etor.Current.Value;

                    switch (data_key)
                    {

                        #region 旧数据兼容
                        case "Lv":
                            lv = GlobalUtils.TryParseInt(data_value);
                            break;
                        case "Energy":
                            energy = GlobalUtils.TryParseInt(data_value, _tables.TbGlobalConfig.InitEnergy);
                            if (energy < 0)
                            {
                                energy = 0;
                            }
                            break;
                        case "EnergyRM":
                            energyRM = GlobalUtils.TryParseInt(data_value, 0);
                            break;
                        case "Gold":
                            gold = GlobalUtils.TryParseUlong(data_value, (ulong)_tables.TbGlobalConfig.InitCash);
                            break;
                        case "GoldRM":
                            goldRM = GlobalUtils.TryParseUlong(data_value, 0);
                            break;
                        case Pearl:
                            pearl = GlobalUtils.TryParseInt(data_value, 0);
                            break;
                        case Diamond:
                            diamond = GlobalUtils.TryParseInt(data_value, 0);
                            break;
                        case "Magnification":
                            magnification = GlobalUtils.TryParseInt(data_value);
                            break;
                        case "EquipRodID":
                            equipRodID = GlobalUtils.TryParseInt(data_value);
                            if (!_tables.TbRodData.DataMap.ContainsKey(equipRodID))
                            {
                                equipRodID = _tables.TbGlobalConfig.InitRodID;
                            }
                            break;
                        case "LastEnergyRecoveryTime":
                            _lastEnergyRecoveryTime = GlobalUtils.TryParseDateTime(data_value, ZZTimeHelper.UtcNow());
                            break;

                        case "RewardNewMap":
                            rewardNewMap = GlobalUtils.TryParseInt(data_value);
                            break;

                        case "vipAllScore":
                            vipAllScore = GlobalUtils.TryParseInt(data_value);
                            break;

                        case "CurrentMapId":
                            currentMapId = GlobalUtils.TryParseInt(data_value);
                            break;
                        case "LastMapId":
                            lastMapId = GlobalUtils.TryParseInt(data_value);
                            break;
                        #endregion 旧数据兼容

                        case "NewRodList":
                            newRodList = Newtonsoft.Json.JsonConvert.DeserializeObject<List<int>>(data_value);
                            break;
                        case "Picture":
                            var fishAlbumData = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, int>>(data_value);
                            GContext.container.Resolve<AlbumData>().fishAlbumData = fishAlbumData.ToDictionary(i => GlobalUtils.TryParseInt(i.Key), i => i.Value);
                            break;
                        case "NewAlbum":
                            GContext.container.Resolve<AlbumData>().newAlbum = Newtonsoft.Json.JsonConvert.DeserializeObject<List<int>>(data_value);
                            break;
                        case "PictureExchangeCD":
                            var exchangeCd = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, double>>(data_value);
                            GContext.container.Resolve<AlbumData>().exchangeCD =
                                exchangeCd.ToDictionary(i => GlobalUtils.TryParseInt(i.Key), i => i.Value);
                            break;

                        case "PhotoRequestCountByDay":
                            var photoRequestCountByDay = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, int>>(data_value);
                            GContext.container.Resolve<AlbumData>().InitGiftToFriendsDay(photoRequestCountByDay);
                            break;
                        case "SeasonId":
                            GContext.container.Resolve<PlayerData>().seasonId = GlobalUtils.TryParseInt(data_value);
                            break;

                        case "MonthlySignEvent":
                            GContext.container.Resolve<SigninData>().monthlySignEvent = Newtonsoft.Json.JsonConvert.DeserializeObject<MonthlySignEvent>(data_value);
                            break;
                        case "NewSignEvent":
                            GContext.container.Resolve<SigninData>().newSignEvent = Newtonsoft.Json.JsonConvert.DeserializeObject<DailySignEvent>(data_value);
                            break;
                        //case "DailyTaskToWeeklyEvent":
                        //    GContext.container.Resolve<TaskData>().SetDailyTaskToWeeklyEvent(data_value);
                        //    break;

                        case "TriggerPackDataList":
                            GContext.container.Resolve<TriggerPackData>().triggerPackList = Newtonsoft.Json.JsonConvert.DeserializeObject<List<TriggerPackBuyData>>(data_value);
                            break;
                        case "GiftVIPDData":
                            var giftVIPDData = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, GiftVIPDData>>(data_value);
                            GContext.container.Resolve<TriggerPackData>().giftVIPDData = giftVIPDData;
                            break;
                        case "FixedTimeShopDic":
                            var FixedTimeshopDic = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<int, FixedTimeEvent>>(data_value);
                            GContext.container.Resolve<TriggerPackData>().SetFixedTimeShopDic(FixedTimeshopDic);
                            break;
                        case "GuideSaveData":
                            try
                            {
                                var guideSaveData = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, GuideSaveData>>(data_value);
                                if (guideSaveData != null)
                                {
                                    GContext.container.Resolve<GuideDataCenter>().GuideSaveDataDic = guideSaveData;
                                }
                            }
                            catch (Exception)
                            {
                                GameDebug.LogWarning($"[PlayerData]LoadPlayerData: Fail to parse GuideSaveData {data_value}!");
                            }
                            break;
                        case "HeistGameCount":
                            GContext.container.Resolve<SmallGameData>().SetHeistGameCount(GlobalUtils.TryParseInt(data_value));
                            break;
                        case "BombGameCount":
                            GContext.container.Resolve<SmallGameData>().SetBombGameCount(GlobalUtils.TryParseInt(data_value));
                            break;
                        case "FishHuntGameCount":
                            GContext.container.Resolve<SmallGameData>().SetFishHuntGameCount(GlobalUtils.TryParseInt(data_value));
                            break;
                        case "ClubSignin":
                            GContext.container.Resolve<ClubService>().SetClubSignin(data_value);
                            break;
                        case "LureDonateData":
                            GContext.container.Resolve<ClubService>().SetLureDonateData(data_value);
                            break;
                        case "FishingBoxData":
                            GContext.container.Resolve<FishingBoxData>().InitData(data_value);
                            break;

                        case "IsOpenAppraise":
                            IsOpenAppraise = true;
                            break;

                        //case "MonthCardData":
                        //    GContext.container.Resolve<MonthCardDataConter>().InitMonthCardData(data_value);
                        //    break;
                        // case "ChallengeData":
                        //     GContext.container.Resolve<FishingChallengeCenter>().InitChallengeData(data_value);
                            // break;
                        case "FishingChallengeData":
                            GContext.container.Resolve<FishingChallengeManager>().InitChallengeData(data_value);
                            break;
                        case OfferChainsChestManager.SaveKey:
                            GContext.container.Resolve<OfferChainsChestManager>().LoadChainsChestData(data_value);
                            break;
                        case HexMapDataManager.SaveKey:
                            GContext.container.Resolve<HexMapDataManager>().LoadUserData(data_value);
                            break;
                        
                        //case "TargetEventPackData":
                        //    GContext.container.Resolve<PlayerShopData>().InitTargetEventData(data_value);
                        //    break;
                        case "BattlePassRecord":
                            GContext.container.Resolve<BattlePassData>().LoadBattlePassRecord(data_value);
                            break;
                        case "BattleTask":
                            GContext.container.Resolve<BattlePassData>().LoadBattleTask(data_value);
                            break;

                        case "IsOpenClubRed":
                            GContext.container.Resolve<ClubService>().IsOpenClubRed = false;
                            break;
                        //case "PokerScoreData":
                        //    GContext.container.Resolve<PokerScoreData>().InitPockerScore(data_value);
                        //    break;

                        case "EventPackData":
                            GContext.container.Resolve<EventPackData>().LoadEventPackData(data_value);
                            break;
                        case "AchievementData":
                            GContext.container.Resolve<AchievementDataManager>().LoadAchievementData(data_value);
                            break;

                        case "PiggyBankPackData":
                            GContext.container.Resolve<PiggyBankPackData>().LoadData(data_value);
                            break;
                        case "GeneralEventPackData":
                            var tempData = JsonConvert.DeserializeObject<GeneralEventPackData>(data_value);
                            int packType = _tables.TbEventPackManager[tempData.redirectID].PackType;
                            switch (packType)
                            {
                                case 3:
                                    GContext.container.Resolve<BargainPackData>().LoadData(tempData);
                                    break;
                                case 4:
                                    GContext.container.Resolve<RodSelectionPackData>().LoadData(tempData);
                                    break;
                                case 5:
                                    GContext.container.Resolve<SelectionPackData>().LoadData(tempData);
                                    break;
                            }
                            break;
                        case "InfiniteBuildingData":
                            InfiniteBuildingData = data_value;
                            break;
                        /* case "EventPartnerData":
                            GContext.container.Resolve<EventPartnerData>().LoadPlayfabData(data_value);
                            break; */
                        case EventWashingConfig.SAVE_DATA_KEY:
                            GContext.container.Resolve<EventWashingDataManager>().GetDataFromServer(data_value);
                            break;
                        case "FootPrint":
                            GContext.container.Resolve<IFootPrintService>().LoadData(data_value);
                            break;
                        case EventShootingRangeData.Key:
                            var data = GContext.container.Resolve<EventShootingRangeData>();
                            if (data == null)
                            {
                                GContext.container.Register<EventShootingRangeData>().AsSingleton();
                                data = GContext.container.Resolve<EventShootingRangeData>();
                            }
                            data.LoadData(data_value);
                            break;
                        case EventPotionConfig.SAVE_DATA_KEY:
                            GContext.container.Resolve<EventPotionDataManager>().GetDataFromServer(data_value);
                            break;
                        case EventPinballConfig.SAVE_DATA_KEY:
                            GContext.container.Resolve<EventPinballDataManager>().GetDataFromServer(data_value);
                            break;
                        case EventScratchTicketConfig.SAVE_DATA_KEY:
                            GContext.container.Resolve<EventScratchTicketDataManager>().GetDataFromServer(data_value);
                            break;
                        case ThanksGivingPackData.Key:
                            GContext.container.Resolve<FishingEventData>().ThanksGivingPackData.LoadData(data_value);
                            break;
                        case ChainPackWithProgressMigrationData.Key:
                            GContext.container.Resolve<FishingEventData>().ChainPackWithProgressMigrationData.LoadData(data_value);
                            break;
                        // case EventBreakPfData.PfKey:
                        //     EventBreakPfData.Stash = EventBreakPfData.Deserialize(data_value);
                        //     break;
                        // case EventCanPlayfabData.PlayFabKey:
                        //     EventCanPlayfabData.Deserialize(data_value).Save();
                        //     break;
                        default:
                            break;
                    }
                }
            }
            GContext.container.Resolve<DiggingGameManager>().InitServerData(userDatas);
            if (userDatas.TryGetValue("NewPlayerDataDic", out string newPlayerDataDic))
            {
                NewPlayerDataDic = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, string>>(newPlayerDataDic);
                SetPlayerData();
            }
        }
        void SetPlayerData()
        {
            string data_value;
            if (NewPlayerDataDic.TryGetValue("lv", out data_value))
            {
                lv = GlobalUtils.TryParseInt(data_value);
            }
            if (NewPlayerDataDic.TryGetValue("gold", out data_value))
            {
                gold = GlobalUtils.TryParseUlong(data_value, (ulong)_tables.TbGlobalConfig.InitCash);
            }
            if (NewPlayerDataDic.TryGetValue("vipS", out data_value))
            {
                vipAllScore = GlobalUtils.TryParseInt(data_value);
            }
            if (NewPlayerDataDic.TryGetValue("energy", out data_value))
            {
                energy = GlobalUtils.TryParseInt(data_value);
                if (energy < 0)
                {
                    energy = 0;
                }
            }
            if (NewPlayerDataDic.TryGetValue("pearl", out data_value))
            {
                pearl = GlobalUtils.TryParseInt(data_value);
            }
            if (NewPlayerDataDic.TryGetValue("mag", out data_value))
            {
                magnification = GlobalUtils.TryParseInt(data_value);
            }
            if (NewPlayerDataDic.TryGetValue("rodID", out data_value))
            {
                equipRodID = GlobalUtils.TryParseInt(data_value);
                if (!_tables.TbRodData.DataMap.ContainsKey(equipRodID))
                {
                    equipRodID = _tables.TbGlobalConfig.InitRodID;
                }
            }
            if (NewPlayerDataDic.TryGetValue("EnergyTime", out data_value))
            {
                _lastEnergyRecoveryTime = GlobalUtils.TryParseDateTime(data_value, ZZTimeHelper.UtcNow());
            }

            if (NewPlayerDataDic.TryGetValue("rewardNewMap", out data_value))
            {
                rewardNewMap = GlobalUtils.TryParseInt(data_value);
            }
            if (NewPlayerDataDic.TryGetValue("energyRM", out data_value))
            {
                energyRM = GlobalUtils.TryParseInt(data_value);
            }
            if (NewPlayerDataDic.TryGetValue("goldRM", out data_value))
            {
                goldRM = GlobalUtils.TryParseUlong(data_value);
            }
            if (NewPlayerDataDic.TryGetValue("diamond", out data_value))
            {
                diamond = GlobalUtils.TryParseInt(data_value);
            }

            if (NewPlayerDataDic.TryGetValue("cMapID", out data_value))
            {
                currentMapId = GlobalUtils.TryParseInt(data_value);
            }
            if (NewPlayerDataDic.TryGetValue("lMapID", out data_value))
            {
                lastMapId = GlobalUtils.TryParseInt(data_value);
            }
        }

        void SavePlayerData(bool remote = true)
        {
            NewPlayerDataDic["lv"] = lv.ToString();
            NewPlayerDataDic["gold"] = gold.ToString();
            NewPlayerDataDic["vipS"] = vipAllScore.ToString();
            NewPlayerDataDic["energy"] = energy.ToString();
            NewPlayerDataDic["pearl"] = pearl.ToString();
            NewPlayerDataDic["mag"] = magnification.ToString();
            NewPlayerDataDic["rodID"] = equipRodID.ToString();
            NewPlayerDataDic["EnergyTime"] = _lastEnergyRecoveryTime.ToString();
            NewPlayerDataDic["rewardNewMap"] = rewardNewMap.ToString();
            NewPlayerDataDic["energyRM"] = energyRM.ToString();
            NewPlayerDataDic["goldRM"] = goldRM.ToString();
            NewPlayerDataDic["diamond"] = diamond.ToString();
            NewPlayerDataDic["cMapID"] = currentMapId.ToString();
            NewPlayerDataDic["lMapID"] = lastMapId.ToString();

            PlayFabMgr.Instance.UpdateUserDataValue("NewPlayerDataDic", Newtonsoft.Json.JsonConvert.SerializeObject(NewPlayerDataDic), remote);
        }
        public void Init()
        {
            OnLvChange();
            VipChange();
            RecoveryEnergy();
        }
        void InitEnergy()
        {
            List<EnergyDef> DataList = _tables.TbEnergyDef.DataList;
            if (magnification >= DataList.Count)
            {
                magnification = 0;
            }
            EnergyDef energyDef = DataList[magnification];
            if (energyDef.Energy >= 0)
            {
                return;
            }
            var buffTimeData = GContext.container.Resolve<BuffDataCenter>().GetWeelyBuffTimeData<SuperEnergyMag>();
            bool isSuperEnergy = buffTimeData != null;
            if (isSuperEnergy)
            {
                return;
            }
            for (int i = DataList.Count - 1; i >= 0; i--)
            {
                if (DataList[i].Energy >= 0)
                {
                    if (i < magnification)
                    {
                        magnification = i;
                    }
                    return;
                }
            }
        }
        public bool ContainsOrGreaterRatio(int ratio)
        {
            List<EnergyDef> DataList = _tables.TbEnergyDef.DataList;
            var buffTimeData = GContext.container.Resolve<BuffDataCenter>().GetWeelyBuffTimeData<SuperEnergyMag>();
            bool isSuperEnergy = buffTimeData != null;
            for (int i = 0; i < DataList.Count; i++)
            {
                int demandEnergy = DataList[i].Energy;
                if (isSuperEnergy)
                {
                    demandEnergy = DataList[i].FishBuffEnergy;
                }
                if (demandEnergy >= 0 && Energy > demandEnergy)
                {
                    if (ratio <= DataList[i].Mag)
                    {
                        return true;
                    }
                }
                else
                {
                    return false;
                }
            }
            return false;
        }
        public int GetMagnification()
        {
            if (magnification >= _tables.TbEnergyDef.DataList.Count)
            {
                magnification = _tables.TbEnergyDef.DataList.Count - 1;
            }
            return _tables.TbEnergyDef.DataList[magnification].Mag;
        }
        public string GetMagnificationIcon()
        {
            if (magnification >= _tables.TbEnergyDef.DataList.Count)
            {
                magnification = _tables.TbEnergyDef.DataList.Count - 1;
            }
            return _tables.TbEnergyDef.DataList[magnification].Icon;
        }
        public int SetLittleMagnification()
        {
            List<EnergyDef> DataList = _tables.TbEnergyDef.DataList;
            for (int i = 3; i >= 0; i--)
            {
                int demandEnergy = DataList[i].Mag;

                if (demandEnergy >= 0)
                {
                    if (Energy >= demandEnergy)
                    {
                        return i;
                    }
                }
            }
            return 0;
        }
        public float GetLuckMultipier()
        {
            if (magnification >= _tables.TbEnergyDef.DataList.Count)
            {
                magnification = _tables.TbEnergyDef.DataList.Count - 1;
            }
            return _tables.TbEnergyDef.DataList[magnification].LuckMultipier;
        }
        public bool GetCanMagnification()
        {
            return GetMagnification() <= Energy;
        }
        public bool IsShowEffectBeilvLoop()
        {
            return _tables.TbEnergyDef.DataList[magnification + 1].Mag <= Energy;
        }
        public bool IsMaxMagnification()
        {
            return magnification >= MagnificationCount - 1;
        }

        bool _isRecoveryEnergy;
        public void RecoveryEnergy(int time)
        {
            _lastEnergyRecoveryTime = ZZTimeHelper.UtcNow();
            SavePlayerData();
            if (!_isRecoveryEnergy)
            {
                CoRecoveryEnergy(time);
                if (Energy < MaxEnergy)
                {
                    SetRecoverNotification();
                }
            }
        }
        private System.Threading.CancellationTokenSource tokenSource;
        public void RecoveryEnergy()
        {
            InitEnergy();
            CoRecoveryEnergy((int)((ZZTimeHelper.UtcNow() - _lastEnergyRecoveryTime).TotalSeconds));
            if (Energy < MaxEnergy)
            {
                SetRecoverNotification();
            }
        }
        public void StopRecoveryEnergy()
        {
            tokenSource?.Cancel();
            tokenSource = null;
        }
        public async void CoRecoveryEnergy(int energyRecoveryTime)
        {
            tokenSource?.Cancel();
            tokenSource = new System.Threading.CancellationTokenSource();
            var token = tokenSource.Token;
            _isRecoveryEnergy = true;
            int initEnergyRestorationSpeed = _tables.TbGlobalConfig.InitEnergyRestorationSpeed * 60;

            while (Energy < MaxEnergy && !token.IsCancellationRequested)
            {
                if (energyRecoveryTime >= initEnergyRestorationSpeed)
                {
                    int count = energyRecoveryTime / initEnergyRestorationSpeed * EnergyRecover;
                    int curEnergy = Energy;
                    Energy += count;
                    energyRecoveryTime %= initEnergyRestorationSpeed;
                    GameDebug.Log($"回复Energy：{Energy}");

                    if (Energy > MaxEnergy)
                    {
                        Energy = MaxEnergy;
                    }
                    int addEnergy = Energy - curEnergy;
#if AGG
                    using (var e = GEvent.GameEvent("auto_hook_revitalized"))
                    {
                        e.AddContent("map_id", lastMapId)
                         .AddContent("change_num", addEnergy);
                    }
                    using (var e = GEvent.GameEvent("item_change", gaSend: false))
                    {
                        e.AddContent("item_id", 1001)
                         .AddContent("state_info", "get")
                         .AddContent("change_num", addEnergy);
                    }
#endif
                    GContext.Publish(new ResAddEvent(1001));
                    _lastEnergyRecoveryTime = ZZTimeHelper.UtcNow().AddSeconds(-energyRecoveryTime);
                    SavePlayerData();
                }
                await Awaiters.Seconds(1);
                if (token.IsCancellationRequested)
                {
                    return;
                }
                energyRecoveryTime = (int)(ZZTimeHelper.UtcNow() - _lastEnergyRecoveryTime).TotalSeconds;
            }
            _isRecoveryEnergy = false;
        }

        public void ReduceEnergy(int reEnergy = 0, bool remote = true)
        {
            if (reEnergy == 0)
            {
                reEnergy = GetMagnification();
            }
            int lastEnergy = Energy;

            if (remote)
            {
                Energy = Mathf.Max(Energy - reEnergy, 0);
            }
            else
            {
                SetEnergy(Energy - reEnergy, false);
            }

            GContext.Publish(new ConditionTypeEvent(ConditionType.ConsumeEnergy, GetMagnification()));
            if (lastEnergy >= MaxEnergy && Energy < MaxEnergy)
            {
                RecoveryEnergy(0);
            }
        }

        public void RecoverEnergy()
        {
            Energy += GetMagnification();
        }
        void SetRecoverNotification()
        {
            var item = _tables.TbNotification.GetOrDefault(RecoverNotificationID);
            if (item != null)
            {
                int en = MaxEnergy - Energy - 1;
                int count = (en / EnergyRecover) + 1;
                DateTime dateTime = _lastEnergyRecoveryTime + TimeSpan.FromMinutes(count * _tables.TbGlobalConfig.InitEnergyRestorationSpeed);
                GContext.container.Resolve<ILocalNotificationService>().
                  ScheduleOneTimeNotification(item.ID, dateTime, LocalizationMgr.GetText(item.Title_l10n_key), LocalizationMgr.GetText(item.Content_l10n_key));
            }
            else
            {
                Debug.LogError($"TbNotification Not {RecoverNotificationID}");
            }
        }
        public TimeSpan GetEnergyRecoveryTimeMAndS()
        {
            return _lastEnergyRecoveryTime + TimeSpan.FromMinutes(_tables.TbGlobalConfig.InitEnergyRestorationSpeed) - ZZTimeHelper.UtcNow();
        }
        public float GrtEscapeDistanceMag()
        {
            float ExtraPoint = 1;
            //地图加成
            MapData data = _tables.TbMapData.GetOrDefault(lastMapId);
            if (data != null)
            {
                ExtraPoint = data.EscapeDistanceMag;
            }
            return ExtraPoint;
        }


        public async void OpenAppraisePopupPanel(int fishId)
        {
            if (lastMapId != _tables.TbMapData.DataList[0].ID && !IsOpenAppraise)
            {
                var fishData = _tables.TbFishData.GetOrDefault(fishId);
                if (fishData != null && fishData.Quality >= 5)
                {
                    await UIManager.Instance.ShowUI(UITypes.AppraisePopupPanel);
                    IsOpenAppraise = true;
                    PlayFabMgr.Instance.UpdateUserDataValue("IsOpenAppraise", "true");
                }
            }
        }

        #region GM相关
        public int SupplyDropIndex = -1;
        #endregion
    }
}