using System.Collections.Generic;
using System.Linq;
using LitJson;
using System;
using UnityEngine;
namespace vnxbqy.UI
{
    public class BlessedLandModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
    {
        #region 功能配置表相关变量
        public int refreshItemCount;                                                //每个福地刷新物品个数
        public int[] itemLevelMaxWorkersArr;                                        //物品等级可用的最大工人数列表  [1级最大人数, 2级, ...]
        public int[] workerFatigueStaminaArr;                                       //工人疲劳状态体力列表 [充沛体力, 正常, 虚弱, 枯竭]，总体力=所有体力相加 状态值 0-充沛；1-正常；2-虚弱；3-枯竭
        public int hiredWorkerItemID;                                               //雇佣工人所需道具物品ID
        public int[] hiredWorkerItemQuantityArr;                                    //雇佣工人所需道具物品个数列表[第1个所需个数, ...]
        public Dictionary<int, List<int>> refreshTypeCostCurrencyValueDict;         //刷新类型消耗货币类型|货币值 {"刷新类型":[货币类型, 货币值], ...}
        public Dictionary<int, int> refreshTypeDailyLimitDict;                      //刷新类型每日次数上限，0不限 {"刷新类型":次数上限, ...}
        public int refreshByHiredWorkerItemCount;                                   //使用工人雇佣道具进行超级刷新单次消耗个数,仅工人数量达上限且今日超级刷新次数已用完时可用
        public int superRefreshDefaultSpecialItemOutputDurationSeconds;             //超级刷新默认产出1个特殊物品有效时长秒，时间到后没有采集则消失 特殊物品设定 - 满级物品，默认自己可采，取消后消失，时间到没采也消失
        public int surroundCount;                                                   //刷新周围福地个数
        public int surroundCooldownS;                                               //刷新周围福地CD，秒
        public int allyHelpCooldownS;                                               //仙盟摇人CD，秒
        public int friendHelpCooldownS;                                             //好友摇人CD，秒
        public int[][] rechargeIDListForActivatingTreasureBowlArr;                  //可激活聚宝盆充值ID列表 [[类型0充值ID], ...] ，配空[]的默认激活
        public int[][][] rewardForFullProgressInTreasureBowlArr;                    //聚宝盆满进度时对应奖励 [[[类型0奖励物品ID,个数,是否拍品], ...],   [[类型1奖励物品ID,个数,是否拍品], ...], ...]
        public Dictionary<int, string> TreasureBowlNameDict;                        //聚宝盆名称
        public int[] TreasureBowlSchedule;                                          //聚宝盆进度
        public int[] TreasureBowlRebate;                                            //聚宝盆返利
        public int maxHelpCount;                                                    //每日可获得帮助奖励次数
        public int[][] helpAwardArr;                                                //帮助成功奖励物品列表 [[物品ID,个数,是否拍品], ...]
        public int[][] realmUnlockPlayerCountArr;                                   //境界解锁周围福地玩家数列表 [[境界,解锁为x个], ...],如果境界小于该配置的最小境界，则默认周围玩家个数取 MineAreaRob 数值2配置，境界大于等于该配置最大境界则取该配置的最大解锁个数
        //<周围福地索引,境界>
        public Dictionary<int, int> realmUnlockPlayerCountDict = new Dictionary<int, int>();
        #endregion
        #region 封包相关变量
        //封包相关
        //B030玩家福地相关信息
        public int WorkerCount;                                                     // 已雇佣工人数
        public int EnergyUsed;                                                      // 今日已消耗体力
        public int RefreshCount;                                                    // 今日福地刷新物品次数 - 普通刷新
        public int RefreshCountSuper;                                               // 今日福地刷新物品次数 - 超级刷新
        public int RefreshCountRob;                                                 // 今日福地刷新周围玩家次数
        public int TreasureCount;                                                   // 聚宝盆类型个数，对应类型 0~n
        public int[] TreasureState;                                                 // 聚宝盆是否已激活列表，[类型0是否已激活, ...]
        public int[] TreasureAward;                                                 // 聚宝盆奖励是否已领取列表，[类型0是否已领取, ...]
        public int[] TreasureProgress;                                              // 聚宝盆进度值列表，[类型0进度值, ...]，满进度100
        public int HelpAwardCount;                                                  // 今日已帮助别人奖励次数
        public uint HousekeeperEndTime;                                             // 自动管家到期时间戳，有值同时也代表免费试用已使用
        //B032 福地物品拉预览结果
        public uint PlayerID;                                                       // 福地所属玩家ID，0默认自己
        public byte ItemIndex;                                                      // 物品所在位置索引0~n
        public byte WorkerPreviewCount;                                             // 上工人预览人数
        public uint NeedSeconds;                                                    // 预计需要时间，秒
        //B033 福地详细信息
        //最新福地详细信息 玩家ID 福地详细信息
        public Dictionary<uint, MineAreaInfo> newAreaDataDict = new Dictionary<uint, MineAreaInfo>();
        //type :playerids
        public Dictionary<int, List<uint>> typeToPlayerIDs = new Dictionary<int, List<uint>>();
        //B034奖励结算相关信息
        public byte AwardType;                                                      // 0-通知有奖励，前端下次进入福地可请求进行结算；1-结算奖励结果通知
        public byte AwardLen;
        public string AwardInfo;                                                    //奖励信息 [物品ID,个数,是否拍品], ...]
                                                                                    //B035 福地记录信息
        public List<MineAreaRecord> mineAreaRecordList = new List<MineAreaRecord>();
        #endregion

        public uint showPlayerId;                                                   //当前展示福地的PlayerId 
        public int cornucopiaIndex = 0;                                             //当前展示的是哪个聚宝盆 默认展示第0个
        public byte detailsIndex = 0;                                               //显示指定index的资源详情
        public uint helpType = 0;                                                   //驱赶界面显示状态 0 自己主动驱逐 1 帮助别人驱逐
        public uint helpPlayerId;                                                   //要帮助谁
        public uint robPlayerId;                                                    //要驱赶谁
        public uint helpItemIndex;                                                  //帮助目标的物品索引
        public uint myPlayerId;                                                     //我的playerId
        public bool isWin = false;
        public bool isStart = false;
        public bool isSkipLv4Tip = false;                                           //本次登录是否跳过存在四级物品二次确认窗口
        public bool isSkipRefreshTip = false;                                       //本次登录是否跳过普通刷新二次确认窗口
        public int lastSurroundRefreshTime;                                         //上次点击寻觅刷新按钮的时间
        public int lastAllyHelpRefreshTime;                                         //上次点击仙盟摇人按钮的时间
        public int lastFriendHelpRefreshTime;                                       //上次点击好友摇人按钮的时间
        public event Action<List<uint>> UpdateNewAreaData;
        public event Action UpdateOtherAreaData;
        public event Action UpdateFellowAndSurroundAreaData;
        public event Action UpdateFindAreaData;
        public event Action UpdateRecordInfo;
        public event Action UpdatePullPreviewMine;
        public Action UpdateMineAreaData;
        public event Action UpdateTurnFightStateInfo;
        public event Action<int> PlayRefreshUIEffect;
        Redpoint mainRedPoint = new Redpoint(MainRedDot.FAIRY_REDPOINT_KEY2, MainRedDot.BlessedLandRedpoint);                                               //福地入口红点
        Redpoint manageRedPoint = new Redpoint(MainRedDot.BlessedLandRedpoint, MainRedDot.BlessedLandRedpoint * 10 + 1);     //管理按钮红点
        Redpoint employRedPoint = new Redpoint(MainRedDot.BlessedLandRedpoint * 10 + 1, MainRedDot.BlessedLandRedpoint * 10 + 2);     //雇佣按钮红点
        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        BlessedLandManageMouseModel blessedLandManageMouseModel { get { return ModelCenter.Instance.GetModel<BlessedLandManageMouseModel>(); } }
        public override void Init()
        {
            #region 读取功能配置表中福地相关数据
            refreshItemCount = int.Parse(FuncConfigConfig.Get("MineAreaBase").Numerical1);
            itemLevelMaxWorkersArr = JsonMapper.ToObject<int[]>(FuncConfigConfig.Get("MineAreaBase").Numerical3);
            workerFatigueStaminaArr = JsonMapper.ToObject<int[]>(FuncConfigConfig.Get("MineAreaWorker").Numerical1);
            hiredWorkerItemID = int.Parse(FuncConfigConfig.Get("MineAreaWorker").Numerical2);
            hiredWorkerItemQuantityArr = JsonMapper.ToObject<int[]>(FuncConfigConfig.Get("MineAreaWorker").Numerical3);
            refreshTypeCostCurrencyValueDict = new Dictionary<int, List<int>>();
            refreshTypeDailyLimitDict = new Dictionary<int, int>();
            var jsonData = JsonMapper.ToObject(FuncConfigConfig.Get("MineAreaRefresh").Numerical1);
            List<string> keyList = jsonData.Keys.ToList();
            for (int i = 0; i < keyList.Count; i++)
            {
                refreshTypeCostCurrencyValueDict.Add(int.Parse(keyList[i]), JsonMapper.ToObject<List<int>>(jsonData[keyList[i]].ToJson()));
            }
            jsonData = JsonMapper.ToObject(FuncConfigConfig.Get("MineAreaRefresh").Numerical2);
            keyList = jsonData.Keys.ToList();
            for (int i = 0; i < keyList.Count; i++)
            {
                refreshTypeDailyLimitDict[int.Parse(keyList[i])] = int.Parse(jsonData[keyList[i]].ToString());
            }
            refreshByHiredWorkerItemCount = int.Parse(FuncConfigConfig.Get("MineAreaRefresh").Numerical3);
            superRefreshDefaultSpecialItemOutputDurationSeconds = int.Parse(FuncConfigConfig.Get("MineAreaSuperItem").Numerical1);
            surroundCount = int.Parse(FuncConfigConfig.Get("MineAreaRob").Numerical2);
            surroundCooldownS = int.Parse(FuncConfigConfig.Get("MineAreaRob").Numerical3);
            allyHelpCooldownS = int.Parse(FuncConfigConfig.Get("MineAreaRob").Numerical4);
            friendHelpCooldownS = int.Parse(FuncConfigConfig.Get("MineAreaRob").Numerical5);
            rechargeIDListForActivatingTreasureBowlArr = JsonMapper.ToObject<int[][]>(FuncConfigConfig.Get("MineAreaTreasure").Numerical1);
            rewardForFullProgressInTreasureBowlArr = JsonMapper.ToObject<int[][][]>(FuncConfigConfig.Get("MineAreaTreasure").Numerical3);
            jsonData = JsonMapper.ToObject(FuncConfigConfig.Get("MineAreaTreasure").Numerical4);
            keyList = jsonData.Keys.ToList();
            TreasureBowlNameDict = new Dictionary<int, string>();
            for (int i = 0; i < keyList.Count; i++)
            {
                TreasureBowlNameDict[int.Parse(keyList[i])] = jsonData[keyList[i]].ToString();
            }
            TreasureBowlSchedule = JsonMapper.ToObject<int[]>(FuncConfigConfig.Get("MineAreaTreasure").Numerical2);
            TreasureBowlRebate = JsonMapper.ToObject<int[]>(FuncConfigConfig.Get("MineAreaTreasure").Numerical5);
            maxHelpCount = int.Parse(FuncConfigConfig.Get("MineAreaHelp").Numerical1);
            helpAwardArr = JsonMapper.ToObject<int[][]>(FuncConfigConfig.Get("MineAreaHelp").Numerical2);
            realmUnlockPlayerCountArr = JsonMapper.ToObject<int[][]>(FuncConfigConfig.Get("MineAreaRob2").Numerical1);
            for (int i = 0; i < realmUnlockPlayerCountArr.Length; i++)
            {
                realmUnlockPlayerCountDict[realmUnlockPlayerCountArr[i][1]] = realmUnlockPlayerCountArr[i][0];
            }

            #endregion
            packModel.refreshItemCountEvent += OnRefreshItem;
            RoleParticularModel.OnRevPackage += OnRevPackage;
        }

        public override void UnInit()
        {
            packModel.refreshItemCountEvent -= OnRefreshItem;
            RoleParticularModel.OnRevPackage -= OnRevPackage;
        }

        void OnRefreshItem(PackType packType, int index, int itemID)
        {
            if (packType == PackType.Item && itemID == hiredWorkerItemID)
            {
                UpdateRedpoint();
            }
        }

        void OnRevPackage(int viewType, int playerID, RoleParticularModel.ViewPlayerData data)
        {
            if (robPlayerId != playerID)
            {
                return;
            }

            if (!WindowCenter.Instance.IsOpen<BlessedLandPKWin>())
            {
                WindowJumpMgr.Instance.WindowJumpToEx("BlessedLandPKWin");
            }
        }

        void UpdateRedpoint()
        {
            if (!FuncOpen.Instance.IsFuncOpen(227))

            {
                return;
            }
            mainRedPoint.state = RedPointState.None;
            manageRedPoint.state = RedPointState.None;
            employRedPoint.state = RedPointState.None;
            int haveCount = packModel.GetItemCountByID(PackType.Item, hiredWorkerItemID);
            int needCount = WorkerCount > hiredWorkerItemQuantityArr.Length - 1 ? hiredWorkerItemQuantityArr.Length - 1 : hiredWorkerItemQuantityArr[WorkerCount];
            mainRedPoint.state = WorkerCount - GetWorkingCount() == 0 ? RedPointState.None : RedPointState.Simple;
            employRedPoint.state = WorkerCount >= hiredWorkerItemQuantityArr.Length ? RedPointState.None : haveCount >= needCount ? RedPointState.Simple : RedPointState.None;
        }

        //将HB033转化为Dictionary<uint, MineAreaInfo>类型的字典 type 0 在先有字典上更新 1 重头生成
        public Dictionary<uint, MineAreaInfo> ProcessHB033(HB033_tagGCMineAreaInfo source, Dictionary<uint, MineAreaInfo> tempDict, int type)
        {
            for (int i = 0; i < source.AreaList.Length; i++)
            {
                var area = source.AreaList[i];
                // 检查是否已存在该PlayerID的MineAreaInfo
                if (tempDict.ContainsKey(area.PlayerID))
                {
                    // 更新现有的MineAreaInfo对象
                    var existingAreaInfo = tempDict[area.PlayerID];
                    existingAreaInfo.PlayerName = area.PlayerName;
                    existingAreaInfo.Job = area.Job;
                    existingAreaInfo.Face = area.Face;
                    existingAreaInfo.FacePic = area.FacePic;
                    existingAreaInfo.RobValue = area.RobValue;
                    existingAreaInfo.MineCount = area.MineCount;

                    // 更新字典的MineItems
                    for (int j = 0; j < area.MineItemList.Length; j++)
                    {
                        var item = area.MineItemList[j];
                        var itemInfo = new MineItemInfo
                        {
                            Index = item.Index,
                            MineID = item.MineID,
                            MineType = item.MineType,
                            UpdTime = item.UpdTime,
                            Position = item.Position,
                            MoveSpeed = item.MoveSpeed,
                            EndTime = item.EndTime,
                            WorkerCount = item.WorkerCount,
                            RobPlayerID = item.RobPlayerID,
                            RobWorkerCount = item.RobWorkerCount,
                            RobPlayerName = item.RobPlayerName,
                            RobFace = item.RobFace,
                            RobJob = item.RobJob,
                            RobFacePic = item.RobFacePic,
                        };
                        // 使用Index作为键值
                        existingAreaInfo.MineItems[item.Index] = itemInfo;
                    }
                }
                else
                {
                    // 创建新的MineAreaInfo对象
                    var newAreaInfo = new MineAreaInfo
                    {
                        PlayerID = area.PlayerID,
                        PlayerName = area.PlayerName,
                        Job = area.Job,
                        Face = area.Face,
                        FacePic = area.FacePic,
                        RobValue = area.RobValue,
                        MineCount = area.MineCount,
                        MineItems = new Dictionary<int, MineItemInfo>()
                    };

                    for (int k = 0; k < area.MineItemList.Length; k++)
                    {
                        var item = area.MineItemList[k];
                        var itemInfo = new MineItemInfo
                        {
                            Index = item.Index,
                            MineID = item.MineID,
                            MineType = item.MineType,
                            UpdTime = item.UpdTime,
                            Position = item.Position,
                            MoveSpeed = item.MoveSpeed,
                            EndTime = item.EndTime,
                            WorkerCount = item.WorkerCount,
                            RobPlayerID = item.RobPlayerID,
                            RobWorkerCount = item.RobWorkerCount,
                            RobPlayerName = item.RobPlayerName,
                            RobFace = item.RobFace,
                            RobJob = item.RobJob,
                            RobFacePic = item.RobFacePic,
                        };
                        // 使用Index作为键值
                        newAreaInfo.MineItems.Add(item.Index, itemInfo);
                    }
                    tempDict.Add(area.PlayerID, newAreaInfo);
                }
            }
            return tempDict;
        }


        public List<uint> ProcessHB033PlayerIDs(HB033_tagGCMineAreaInfo source)
        {
            List<uint> tmpList = new List<uint>();
            for (int i = 0; i < source.AreaList.Length; i++)
            {
                var area = source.AreaList[i];
                tmpList.Add(area.PlayerID);
            }
            return tmpList;
        }

        public bool TryGetRefreshTypeDailyLimitValue(int refreshType, out int maxLimit)
        {
            return refreshTypeDailyLimitDict.TryGetValue(refreshType, out maxLimit);
        }

        //通过刷新类型 获取消耗货币类型和货币值 返回false说明是免费
        //refreshType 0-普通；1-超级；2-周围刷新
        public bool TryGetRefreshTypeCostCurrencyValue(int refreshType, out int moneyType, out int moneyValue)
        {
            moneyType = 0;
            moneyValue = 0;
            if (!refreshTypeCostCurrencyValueDict.TryGetValue(refreshType, out var info))
                return false;
            moneyType = info[0];
            moneyValue = info[1];
            return true;
        }


        //获得自己福地当前Cell的显示状态
        //0 无物品 1 有物品-超级物品-无人拉 2 有物品-超级物品-自己拉
        //3 有物品-普通物品-无人拉 4 有物品-普通物品-自己拉 5 有物品-普通物品-对方拉
        //6 有物品-普通物品-双方拉-向自己移动 7 有物品-普通物品-双方拉-向对方移动
        public int GetMyBlessedLandCellState(int index)
        {
            MineItemInfo mineItem = newAreaDataDict[myPlayerId].MineItems[index];

            if (mineItem.MineID == 0)   //没有物品
                return 0;

            if (mineItem.MineType == 1) //是超级物品
                return mineItem.WorkerCount > 0 ? 2 : 1; //自己是否拉取

            if (mineItem.WorkerCount > 0)   //自己有拉普通物品
            {
                if (mineItem.RobWorkerCount > 0)//有抢夺者
                {
                    return mineItem.WorkerCount >= mineItem.RobWorkerCount ? 6 : 7; //移动方向
                }
                else
                {
                    return 4;
                }
            }
            else
            {
                return mineItem.RobWorkerCount > 0 ? 5 : 3;
            }
        }

        //获得他人福地当前Cell的显示状态
        //0 无物品 1 有物品-超级物品-无人拉 2 有物品-超级物品-房主拉
        //3 有物品-普通物品-无人拉 4 有物品-普通物品-房主拉 5 有物品-普通物品-玩家拉 6 有物品-普通物品-别人拉
        //7 有物品-普通物品-房主和玩家抢-向房主移动 8 有物品-普通物品-房主和玩家抢-向玩家移动
        //9 有物品-普通物品-房主和别人抢-向房主移动 10 有物品-普通物品-房主和别人抢-向别人移动
        public int GetOtherBlessedLandCellState(int index)
        {
            MineItemInfo mineItems = newAreaDataDict[showPlayerId].MineItems[index];
            if (mineItems.MineID == 0)  // 无物品
                return 0;
            if (mineItems.MineType == 1)    //是超级物品
                return mineItems.WorkerCount > 0 ? 2 : 1;    //房主是否拉取

            if (mineItems.WorkerCount > 0)   //房主拉普通物品
            {
                if (mineItems.RobWorkerCount > 0)   //有抢夺者
                {
                    if (mineItems.RobPlayerID == myPlayerId)     //抢夺者是玩家
                    {
                        return mineItems.WorkerCount >= mineItems.RobWorkerCount ? 7 : 8;  //移动方向
                    }
                    else
                    {
                        return mineItems.WorkerCount >= mineItems.RobWorkerCount ? 9 : 10;
                    }
                }
                else
                {
                    return 4;
                }
            }
            else
            {
                if (mineItems.RobWorkerCount > 0)   //有抢夺者
                {
                    return mineItems.RobPlayerID == myPlayerId ? 5 : 6;//抢夺者是玩家
                }
                else
                {
                    return 3;
                }
            }
        }

        //获得福地管理当前Cell的显示状态 
        //1 自己福地-有超级物品-自己拉 2 自己福地-有普通物品-自己拉
        //3 自己福地-有普通物品-自己和其他玩家抢-向自己移动 4 自己福地-有普通物品-自己和其他玩家抢-向对方移动
        //5 别人福地-有普通物品-自己抢
        //6 别人福地-有普通物品-房主和玩家抢-向房主移动 7 别人福地-有普通物品-房主和玩家抢-向玩家移动 
        public int GetManageCellState(int playerId, int index)
        {
            var mineItems = newAreaDataDict[(uint)playerId].MineItems[index];
            if (playerId == myPlayerId)
            {
                if (mineItems.MineType == 1)
                    return 1;

                if (mineItems.RobWorkerCount > 0)//有抢夺者
                {
                    return mineItems.WorkerCount >= mineItems.RobWorkerCount ? 3 : 4; //移动方向
                }
                else
                {
                    return 2;
                }
            }
            else
            {
                if (mineItems.WorkerCount > 0)  //房主有防守
                {
                    return mineItems.WorkerCount >= mineItems.RobWorkerCount ? 6 : 7; //移动方向
                }
                else
                {
                    return 5;
                }
            }
        }

        //获得福地记录当前Cell的显示状态 0 自己拉自己的 1 自己拉别人的 2 别人抢我的
        public int GetRecordState(int index)
        {
            if (mineAreaRecordList[index].RecordType == 2)
                return 2;
            if (mineAreaRecordList[index].TagPlayerID == myPlayerId)
                return 0;
            return 1;
        }

        //获得当前聚宝盆的显示状态 0 未激活 1 已激活-不能领 2 已激活-可领取 3已激活-已领取  
        public int GetCornucopiaState()
        {
            if (TreasureState[cornucopiaIndex] == 1)    //是否激活
            {
                if (TreasureAward[cornucopiaIndex] == 1)  //是否获得
                {
                    return 3;
                }
                else
                {
                    return TreasureProgress[cornucopiaIndex] == 100 ? 2 : 1; //是否可领
                }
            }
            else
            {
                return 0;
            }
        }

        //自己的福地当前能否进行刷新 0普通刷新 1超级刷新
        public bool IsRefresh(int type)
        {
            bool isPiad = TryGetRefreshTypeCostCurrencyValue(type, out int moneyType, out int moneyValue);

            if (type == 0)
            {
                //需要的货币不够
                if (isPiad)
                {
                    if (UIHelper.GetMoneyCnt(moneyType) < (ulong)moneyValue)
                        return false;
                }
                return true;
            }
            else
            {
                bool isLimit = TryGetRefreshTypeDailyLimitValue(1, out int maxLimit);
                if (isLimit)
                {
                    //超级刷新超出了每日刷新次数上限
                    if (RefreshCountSuper >= maxLimit)
                        return false;
                }

                //需要的货币不够
                if (isPiad)
                {
                    if (UIHelper.GetMoneyCnt(moneyType) < (ulong)moneyValue)
                        return false;
                }
                return true;
            }
        }

        //得到冷却结束时间 0 寻觅刷新按钮 1 仙盟摇人按钮 2 好友摇人按钮
        public int GetCoolDownEndTime(int type)
        {
            DateTime overTime;
            if (type == 0)
            {
                if (lastSurroundRefreshTime == 0)
                    return 0;
                overTime = TimeUtility.GetTime((uint)(lastSurroundRefreshTime + surroundCooldownS));
            }
            else if (type == 1)
            {
                if (lastAllyHelpRefreshTime == 0)
                    return 0;
                overTime = TimeUtility.GetTime((uint)(lastAllyHelpRefreshTime + allyHelpCooldownS));
            }
            else if (type == 2)
            {
                if (lastFriendHelpRefreshTime == 0)
                    return 0;
                overTime = TimeUtility.GetTime((uint)(lastFriendHelpRefreshTime + friendHelpCooldownS));
            }
            else
            {
                return 0;
            }
            if (TimeUtility.ServerNow > overTime)
                return 0;
            return (int)(overTime - TimeUtility.ServerNow).TotalSeconds;
        }
        //记录时间显示 如果是当天的显示时:分 昨天的显示昨天 前天的显示前天 更早的显示x天前
        public string GetTimeDisplay(uint recordTime)
        {
            // 使用TimeUtility中定义的OriginalTime
            DateTime recordDateTime = TimeUtility.OriginalTime.AddSeconds(recordTime);
            TimeSpan timeDifference = TimeUtility.ServerNow.Date - recordDateTime.Date;
            int daysDifference = timeDifference.Days;

            if (daysDifference == 0) // 今天
            {
                return recordDateTime.ToString("H:mm"); // 显示时:分
            }
            else if (daysDifference == 1) // 昨天
            {
                return Language.Get("BlessedLand029");
            }
            else if (daysDifference == 2) // 前天
            {
                return Language.Get("BlessedLand030");
            }
            else // 更早
            {
                return Language.Get("BlessedLand031", daysDifference);
            }
        }
        //当前有多少工作中的工人
        public int GetWorkingCount()
        {
            int result = 0;
            List<uint> KeyList = newAreaDataDict.Keys.ToList();
            for (int i = 0; i < KeyList.Count; i++)
            {
                uint key = KeyList[i];
                MineAreaInfo originalMineAreaInfo = newAreaDataDict[key];
                if (originalMineAreaInfo.PlayerID == myPlayerId)
                {
                    List<int> itemKeys = originalMineAreaInfo.MineItems.Keys.ToList();
                    for (int j = 0; j < itemKeys.Count; j++)
                    {
                        int itemKey = itemKeys[j];
                        MineItemInfo originalMineItemInfo = originalMineAreaInfo.MineItems[itemKey];
                        result += originalMineItemInfo.WorkerCount;
                    }
                }
                else
                {
                    List<int> itemKeys = originalMineAreaInfo.MineItems.Keys.ToList();
                    for (int j = 0; j < itemKeys.Count; j++)
                    {
                        int itemKey = itemKeys[j];
                        MineItemInfo originalMineItemInfo = originalMineAreaInfo.MineItems[itemKey];
                        if (originalMineAreaInfo.MineItems[itemKey].RobPlayerID == myPlayerId)
                        {
                            result += originalMineItemInfo.RobWorkerCount;
                        }
                    }
                }
            }
            return result;
        }

        //当前福地的指定资源当前有多少派遣中的工人
        public int GetItemWorkingCount(uint playerId, int index)
        {
            if (playerId == myPlayerId)
            {
                return newAreaDataDict[playerId].MineItems[index].WorkerCount;
            }
            else
            {
                if (newAreaDataDict[playerId].MineItems[index].RobPlayerID == myPlayerId)
                {
                    return newAreaDataDict[playerId].MineItems[index].RobWorkerCount;
                }
                else
                {
                    return 0;
                }
            }
        }

        //您不能同时采集同一位道友的资源
        public bool IsSnatchItem()
        {
            var mineItems = newAreaDataDict[showPlayerId].MineItems;
            for (int i = 0; i < mineItems.Count; i++)
            {
                if (mineItems[i].RobPlayerID == myPlayerId)
                {
                    return true;
                }
            }
            return false;
        }

        //对象福地是否有被我正在采集中
        public bool IsSnatchItem(uint playerId)
        {
            var mineItems = newAreaDataDict[playerId].MineItems;
            for (int i = 0; i < mineItems.Count; i++)
            {
                if (mineItems[i].RobPlayerID == myPlayerId)
                {
                    return true;
                }
            }
            return false;
        }


        //将byte[]转成int[]
        int[] ConvertByteArrayToIntArray(byte[] byteArray)
        {
            int[] intArray = new int[byteArray.Length];
            for (int i = 0; i < byteArray.Length; i++)
            {
                intArray[i] = byteArray[i];
            }
            return intArray;
        }

        //返回假人名字
        public string GetNameForPlayerId(int playerId)
        {
            if (playerId == 0)
                return StringUtility.Contact(RandomNameConfig.Get(1).RandomName1, RandomNameConfig.Get(1).RandomName2);
            return StringUtility.Contact(RandomNameConfig.Get(playerId % 797).RandomName1, RandomNameConfig.Get(playerId % 1793).RandomName2);
        }

        //返回假人头像
        public AvatarModel GetModelForPlayerId(int playerId)
        {
            int[] numbers = { 1, 2 };
            return AvatarHelper.GetDefaultAvatarModel(numbers[playerId % 2]);
        }

        //获得工人体力一共有多少
        public int GetTotalEnergy()
        {
            int totalEnergy = 0;
            for (int i = 0; i < workerFatigueStaminaArr.Length; i++)
            {
                totalEnergy += workerFatigueStaminaArr[i];
            }
            return totalEnergy;
        }

        //检查当前我的福地上是否存在大于等于4级的物品且没有被我方拉取
        public bool IsGreaterLv4Item()
        {
            if (!newAreaDataDict.ContainsKey(myPlayerId))
                return false;
            var MineItems = newAreaDataDict[myPlayerId].MineItems;
            var keyList = MineItems.Keys.ToList();
            for (int i = 0; i < keyList.Count; i++)
            {

                int mineID = MineItems[keyList[i]].MineID;
                if (mineID == 0 || !MineAreaItemConfig.GetKeys().Contains(mineID.ToString()))
                    continue;
                int itemLV = MineAreaItemConfig.Get(mineID).ItemLV;
                if (itemLV >= 4)
                {
                    if (MineItems[keyList[i]].WorkerCount > 0 && MineItems[keyList[i]].WorkerCount >= MineItems[keyList[i]].RobWorkerCount)
                        return false;
                    return true;
                }

            }
            return false;
        }
        //当前空闲工人数量
        public int GetNowFreeWorkerCount()
        {
            return Mathf.Max(WorkerCount - GetWorkingCount(), 0);
        }
        //当前可用工人体力
        public int GetNowCanUseEnergy()
        {
            return Mathf.Max(GetTotalEnergy() - EnergyUsed - GetWorkingCount(), 0);
        }

        public void SendCA504Pack(byte rewardType, uint dataEx, byte dataExStrLen = 0, string dataExStr = "")
        {
            var pack = new CA504_tagCMPlayerGetReward()
            {
                RewardType = rewardType,
                DataEx = dataEx,
                DataExStrLen = dataExStrLen,
                DataExStr = dataExStr
            };
            GameNetSystem.Instance.SendInfo(pack);
        }

        public void SendCB030Pack(uint playerId, byte itemIndex, byte workerCount, byte isPreview)
        {
            var pak = new CB030_tagCMMineItemPull
            {
                PlayerID = playerId,
                ItemIndex = itemIndex,
                WorkerCount = workerCount,
                IsPreview = isPreview
            };
            GameNetSystem.Instance.SendInfo(pak);
        }

        public void SendCB031Pack(int refreshType)
        {
            var pack = new CB031_tagCMMineItemRefresh()
            {
                RefreshType = (byte)refreshType
            };
            GameNetSystem.Instance.SendInfo(pack);
        }

        public void SendCB032Pack()
        {
            var pack = new CB032_tagCMMineWorkerEmploy();
            GameNetSystem.Instance.SendInfo(pack);
        }

        public void SendCB033Pack(byte queryType, uint queryValue = 0)
        {
            var pack = new CB033_tagCGMineAreaView()
            {
                QueryType = queryType,
                QueryValue = queryValue
            };
            GameNetSystem.Instance.SendInfo(pack);
        }

        public void SendCB034Pack()
        {
            var pack = new CB034_tagCGMineAreaAwardGet();
            GameNetSystem.Instance.SendInfo(pack);
        }

        public void SendCB410Pack(uint mapID, ushort funcLineID, byte tagType, uint tagID, uint[] valueList)
        {
            var pack = new CB410_tagCMTurnFight();
            pack.MapID = mapID;
            pack.FuncLineID = funcLineID;
            pack.TagType = tagType;
            pack.TagID = tagID;
            pack.ValueCount = (byte)valueList.Length;
            pack.ValueList = valueList;
            GameNetSystem.Instance.SendInfo(pack);
            //TurnFightModel.Instance.StartTurnFight((int)mapID, funcLineID, 1, (int)playerID, valueList);
        }

        public void UpdateDetailedBlessedLandPullPreviewRet(HB032_tagGCMineItemPullPreviewRet vNetData)
        {
            PlayerID = vNetData.PlayerID;
            ItemIndex = vNetData.ItemIndex;
            WorkerPreviewCount = vNetData.WorkerCount;
            NeedSeconds = vNetData.NeedSeconds;
            UpdatePullPreviewMine?.Invoke();
        }

        public void UpdateMineAreaRecordInfo(HB035_tagGCMineAreaRecordInfo vNetData)
        {
            mineAreaRecordList.Clear();
            var vNetList = vNetData.AreaRecordList;
            for (int i = 0; i < vNetList.Length; i++)
            {
                MineAreaRecord tempMineAreaRecord = new MineAreaRecord();
                tempMineAreaRecord.RecordType = vNetList[i].RecordType;
                tempMineAreaRecord.TagPlayerID = vNetList[i].TagPlayerID;
                tempMineAreaRecord.RecordTime = vNetList[i].RecordTime;
                tempMineAreaRecord.MineID = vNetList[i].MineID;
                tempMineAreaRecord.TagPlayerName = vNetList[i].TagPlayerName;
                tempMineAreaRecord.TagJob = vNetList[i].TagJob;
                tempMineAreaRecord.TagFace = vNetList[i].TagFace;
                tempMineAreaRecord.TagFacePic = vNetList[i].TagFacePic;
                mineAreaRecordList.Add(tempMineAreaRecord);
            }
            UpdateRecordInfo?.Invoke();

        }

        public void UpdateMineAreaAwardInfo(HB034_tagGCMineAreaAwardInfo vNetData)
        {
            AwardType = vNetData.AwardType;
            AwardLen = vNetData.AwardLen;
            AwardInfo = vNetData.AwardInfo;

            if (AwardType == 0)
            {
                //必须在任意福地窗口打开的前提下才能领取奖励
                if (WindowCenter.Instance.IsOpen<BlessedLandCornucopiaWin>() || WindowCenter.Instance.IsOpen<BlessedLandDetailsWin>() ||
                    WindowCenter.Instance.IsOpen<BlessedLandManageWin>() || WindowCenter.Instance.IsOpen<BlessedLandOtherWin>() ||
                    WindowCenter.Instance.IsOpen<BlessedLandPKWin>() || WindowCenter.Instance.IsOpen<BlessedLandRecordWin>() ||
                    WindowCenter.Instance.IsOpen<BlessedLandSeekWin>() || WindowCenter.Instance.IsOpen<BlessedLandWin>())
                {
                    SendCB034Pack();
                }
            }
            else if (AwardType == 1)
            {
                List<Item> itemList = new List<Item>();
                int[][] AwardArr = JsonMapper.ToObject<int[][]>(vNetData.AwardInfo);
                if (AwardArr.IsNullOrEmpty())
                    return;
                itemList.Clear();
                for (int i = 0; i < AwardArr.Length; i++)
                {
                    itemList.Add(new Item(AwardArr[i][0], AwardArr[i][1]));
                }
                ItemLogicUtility.Instance.ShowGetItem(itemList, "", 5, "", () =>
                {
                    LimitedTimeLuxuryGiftModel.Instance.IsItemIdShow(28, hiredWorkerItemID, hiredWorkerItemQuantityArr[Mathf.Min(WorkerCount, hiredWorkerItemQuantityArr.Length - 1)], 1, 0);
                }, true);
            }

        }

        public void UpdatePlayerTerritoryBlessedLandInformation(HB030_tagMCPlayerMineAreaInfo info)
        {
            WorkerCount = info.WorkerCount;
            EnergyUsed = info.EnergyUsed;
            RefreshCount = (int)info.RefreshCount;
            RefreshCountSuper = info.RefreshCountSuper;
            TreasureCount = info.TreasureCount;
            HousekeeperEndTime = info.HousekeeperEndTime;
            TreasureState = ConvertByteArrayToIntArray(info.TreasureState);
            TreasureAward = ConvertByteArrayToIntArray(info.TreasureAward);
            TreasureProgress = ConvertByteArrayToIntArray(info.TreasureProgress);
            HelpAwardCount = info.HelpAwardCount;
            //查看敌对福地（原道友福地查看）时的回包才有敌对值，即 QueryType = 2时才有敌对值同步，其他都为0
            //因为修改后只有有敌对值的才会在敌对福地列表中，所以也可以理解为敌对值为0时不用更新敌对值，仅更新大于0的即可
            if (info.RefreshCountSuper > 0)
            {
                RefreshCountRob = info.RefreshCountSuper;
            }
            UpdateMineAreaData?.Invoke();
            UpdateRedpoint();
        }
        public int QueryType;
        public int QueryValue;
        public void UpdateDetailedBlessedLandInformation(HB033_tagGCMineAreaInfo source)
        {
            //QueryType = 99 时为刷新同步
            //QueryValue = 0 - 普通刷新； 1 - 超级刷新
            QueryType = source.QueryType;
            QueryValue = (int)source.QueryValue;


            List<uint> playerIdList = new List<uint>();
            for (int i = 0; i < source.AreaList.Length; i++)
            {
                uint playerId = source.AreaList[i].PlayerID;
                if (!playerIdList.Contains(playerId))
                {
                    playerIdList.Add(playerId);
                }
            }

            newAreaDataDict = ProcessHB033(source, newAreaDataDict, 0);

            switch (source.QueryType)
            {
                case 0:
                    UpdateNewAreaData?.Invoke(playerIdList);
                    UpdateRedpoint();
                    break;
                case 1:
                    UpdateNewAreaData?.Invoke(playerIdList);
                    UpdateFindAreaData?.Invoke();
                    break;
                case 2:
                    typeToPlayerIDs[2] = ProcessHB033PlayerIDs(source);
                    UpdateFellowAndSurroundAreaData?.Invoke();
                    break;
                case 3:
                    typeToPlayerIDs[3] = ProcessHB033PlayerIDs(source);
                    UpdateFellowAndSurroundAreaData?.Invoke();
                    if (blessedLandManageMouseModel.startState && blessedLandManageMouseModel.isTrigger)
                    {
                        blessedLandManageMouseModel.isTrigger = false;
                        blessedLandManageMouseModel.StratAuto();
                    }
                    break;
                case 99:
                    PlayRefreshUIEffect?.Invoke(QueryValue);
                    UpdateNewAreaData?.Invoke(playerIdList);
                    UpdateRedpoint();
                    break;
            }

        }

        //0 寻觅刷新按钮 1 仙盟摇人按钮 2 好友摇人按钮
        public void SetTime(int type)
        {
            if (type == 0)
            {
                lastSurroundRefreshTime = TimeUtility.AllSeconds;
            }
            else if (type == 1)
            {
                lastAllyHelpRefreshTime = TimeUtility.AllSeconds;
            }
            else if (type == 2)
            {
                lastFriendHelpRefreshTime = TimeUtility.AllSeconds;
            }
        }

        public void SaveAllTime()
        {
            int[] arr = new int[3];
            arr[0] = lastSurroundRefreshTime;
            arr[1] = lastAllyHelpRefreshTime;
            arr[2] = lastFriendHelpRefreshTime;
            LocalSave.SetIntArray(StringUtility.Contact("xshl_", myPlayerId), arr);
        }

        public void LoadAllTime()
        {
            int[] arr = LocalSave.GetIntArray(StringUtility.Contact("xshl_", myPlayerId));
            if (arr != null && arr.Length == 3)
            {
                lastSurroundRefreshTime = arr[0];
                lastAllyHelpRefreshTime = arr[1];
                lastFriendHelpRefreshTime = arr[2];
            }
            else
            {
                lastSurroundRefreshTime = 0;
                lastAllyHelpRefreshTime = 0;
                lastFriendHelpRefreshTime = 0;
            }
        }

        public void OnBeforePlayerDataInitialize()
        {
            WorkerCount = 0;
            EnergyUsed = 0;
            RefreshCount = 0;
            RefreshCountSuper = 0;
            TreasureCount = 0;
            TreasureState = null;
            TreasureAward = null;
            TreasureProgress = null;
            HelpAwardCount = 0;
            PlayerID = 0;
            ItemIndex = 0;
            WorkerPreviewCount = 0;
            NeedSeconds = 0;
            newAreaDataDict.Clear();
            typeToPlayerIDs.Clear();

            AwardType = 0;
            AwardLen = 0;
            AwardInfo = null;
            mineAreaRecordList.Clear();
        }

        public void OnPlayerLoginOk()
        {
            myPlayerId = PlayerDatas.Instance.PlayerId;
            showPlayerId = myPlayerId;
            LoadAllTime();
        }

        public void UpdateTurnFightState(HB420_tagMCTurnFightState vNetData)
        {
            if (vNetData.MapID == 1 && vNetData.TagType == 1 && vNetData.TagID == robPlayerId && vNetData.State == 4)
            {
                JsonData Data = JsonMapper.ToObject(vNetData.Msg);
                isWin = int.Parse(Data["isWin"].ToString()) == 1;
                UpdateTurnFightStateInfo?.Invoke();
            }
        }
    }
}


public class MineItemInfo
{
    public byte Index;              // 矿物所在福地位置索引，0~n
    public ushort MineID;           // 矿物ID，对应福地采集表中ID，0代表该索引位置没有矿物
    public byte MineType;           // 矿物类型：0-常规；1-超级
    public uint UpdTime;            // 最后一次更新时间戳
    public byte PosLen;
    public string Position;         // 最后一次更新时所在位置百分比，0~100，支持小数，下0上100，可认为分为100格，速度为 x格/秒
    public byte SpeedLen;
    public string MoveSpeed;        // 移动速度，x格/秒，支持小数
    public uint EndTime;            // 拉取结束时间戳
    public byte WorkerCount;        // 工人个数，为0时代表福地玩家没有使用工人拉回
    public uint RobPlayerID;        // 抢夺玩家ID，为0时代表没人抢夺
    public byte RobWorkerCount;     // 抢夺工人个数
    public string RobPlayerName;
    public byte RobJob;
    public uint RobFace;
    public uint RobFacePic;
}
public class MineAreaInfo
{
    public uint PlayerID;            // 福地所属玩家ID，可能是自己或其他玩家ID，当ID小于10000时为假人
    public string PlayerName;        // 可能为空，如自己或假人
    public byte Job;
    public uint Face;
    public uint FacePic;
    public uint RobValue;
    public byte MineCount;
    public Dictionary<int, MineItemInfo> MineItems = new Dictionary<int, MineItemInfo>();
}

public class MineAreaRecord
{
    public byte RecordType;         // 记录类型；1-自己拉物品；2-物品被人抢
    public uint TagPlayerID;        // 目标玩家ID，等于自己玩家ID时代表拉自己的，反之为抢别人的
    public uint RecordTime;         // 记录时间戳
    public ushort MineID;           // 矿物ID，对应福地采集表中ID
    public string TagPlayerName;
    public byte TagJob;
    public uint TagFace;
    public uint TagFacePic;
}