using System;
using System.Text;
using Sog;
using ProtoCSStruct;
using System.Threading;

namespace GameDB
{
    public static class RoleOp
    {
        //gm用可以不用考虑线程安全
        private static SSGmQueryUserRoletInfoRes queryRoleRes = new SSGmQueryUserRoletInfoRes();
        public static void OnGMQueryRoleReq(uint remoteAppID, StructPacket packet, GameDBOperator dbOperator)
        {
            ref SSGmQueryUserRoleInfoReq queryRoleReq = ref packet.GetMessage<SSGmQueryUserRoleInfoReq>();

            TraceLog.Debug("OnQueryRoleReq uid {0}", queryRoleReq.Uid);

            //SSGmQueryUserRoletInfoRes queryRoleRes = new SSGmQueryUserRoletInfoRes
            //{
            // Id = queryRoleReq.Id ,
            // ReqType = queryRoleReq.ReqType
            //};
            queryRoleRes.Clear();
            queryRoleRes.Id = queryRoleReq.Id;
            queryRoleRes.ReqType = queryRoleReq.ReqType;
            long freezeTime = 0;
            long freeType = 0;
            string freezeReasonStr = "";
            long enableMsgTime = 0;
            int ret = dbOperator.QueryFreezeTime(queryRoleReq.Uid, out freezeTime, out freeType, out freezeReasonStr, out enableMsgTime);
            if(ret == -1)
            {
                TraceLog.Error("OnQueryRoleReq.QueryFreezeTime exception ret = -1");
                queryRoleRes.Ret = -1;
            }
            
            // 封号
            long nowTime = GameDBServerUtils.GetTimeSecond();
            if (nowTime <= freezeTime)
            {
				TraceLog.Debug("OnQueryRoleReq query role uid {0} freezed freezeTime {1} nowTime {2}"
                    , queryRoleReq.Uid, freezeTime, nowTime);
                queryRoleRes.Ret = (int)CSErrCode.FreezePlayer;
                queryRoleRes.FreezeTime = freezeTime;
                queryRoleRes.FreezeReason = (FreezeReasonType)freeType;
                queryRoleRes.FreezeReasonStr.SetString(freezeReasonStr);
            }
            
            string firebasePushId = null;
            int realmId = 0;
            bool bsuccess = dbOperator.QueryRole(queryRoleReq.Uid,
                ref queryRoleRes.RoleBase,
                ref queryRoleRes.RoleData,
                ref queryRoleRes.UnimportanceData,
                ref queryRoleRes.DropRateData,
                out firebasePushId,
                out realmId);


            if (bsuccess)
            {
                queryRoleRes.Ret = 0;
                queryRoleRes.ReqRealmId = queryRoleReq.ReqRealmId;
                queryRoleRes.DbRealmId = realmId;
                TraceLog.Debug("OnQueryRoleReq query role success, uid {0}  level {1} exp {2}",
                    queryRoleRes.RoleBase.Uid, queryRoleRes.RoleBase.Level, queryRoleRes.RoleBase.Exp);
                 
            } 
            GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID,
                (int)SSGameMsgID.GmQueryUserRoleRes, ref queryRoleRes, packet.ObjectID, packet.ServerID);
        }
        class SSQueryRoleDropDbResC
        {
            public SSQueryRoleDropDbRes res = new SSQueryRoleDropDbRes();
            public int id = 0;
            public static int idinr = 0;
            public SSQueryRoleDropDbResC()
            {
                Interlocked.Increment(ref idinr); // 原子增加操作 
                id = idinr;
                TraceLog.Trace("SSQueryRoleDropDbRes id = {0} create at thread {1}", id, Thread.CurrentThread.ManagedThreadId);
            }
        }
        private static ThreadLocal<SSQueryRoleDropDbResC> sSQueryRoleDropDbRes = new ThreadLocal<SSQueryRoleDropDbResC>(() =>
        {
            return new SSQueryRoleDropDbResC();
        });
        public static void OnQueryRoleReq(uint remoteAppID, StructPacket packet, GameDBOperator dbOperator)
        {
            ref SSQueryRoleDbReq queryRoleReq = ref packet.GetMessage<SSQueryRoleDbReq>();

            TraceLog.Debug("OnQueryRoleReq uid {0}", queryRoleReq.Uid);

            SSQueryRoleDbRes queryRoleRes = new SSQueryRoleDbRes
            {
                Uid = queryRoleReq.Uid,
                IsGm = queryRoleReq.IsGm,
                FromUid = queryRoleReq.FromUid,
                FromGameSvr = queryRoleReq.FromGameSvr,
                CommParams = queryRoleReq.CommParams,
            };

            long freezeTime = 0;
            long freeType = 0;
            string freezeReasonStr = "";
            long enableMsgTime = 0;
            int ret = dbOperator.QueryFreezeTime(queryRoleReq.Uid, out freezeTime,out freeType, out freezeReasonStr, out enableMsgTime);
            if (ret == -1)
            {
                TraceLog.Error("OnQueryRoleReq.QueryFreezeTime exception ret = -1");
                queryRoleRes.Ret = -1;
                GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID,
                    (int)SSGameMsgID.QueryRoleDbRes, ref queryRoleRes, packet.ObjectID, packet.ServerID);
                return;
            }

            // 封号
            long nowTime = GameDBServerUtils.GetTimeSecond();
            if (nowTime <= freezeTime)
            {
                TraceLog.Debug("OnQueryRoleReq query role uid {0} freezed freezeTime {1} nowTime {2}"
                    , queryRoleReq.Uid, freezeTime, nowTime);
                queryRoleRes.Ret = (int)CSErrCode.FreezePlayer;
                queryRoleRes.FreezeTime = freezeTime;
                queryRoleRes.FreezeReason = (FreezeReasonType)freeType;
                queryRoleRes.FreezeReasonStr.SetString(freezeReasonStr);

                GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID,
                    (int)SSGameMsgID.QueryRoleDbRes, ref queryRoleRes, packet.ObjectID, packet.ServerID);
                return;
            }
            // 禁言
            if (nowTime <= enableMsgTime)
            {
                queryRoleRes.GagChatEndTime = enableMsgTime;
            }
            ref SSQueryRoleDropDbRes dropres = ref sSQueryRoleDropDbRes.Value.res;
            dropres.Clear();
            dropres.Uid = queryRoleReq.Uid;
            string firebasePushId = null;
            int realmId = 0;
            bool bsuccess = dbOperator.QueryRole(queryRoleReq.Uid,
                ref queryRoleRes.RoleBase,
                ref queryRoleRes.RoleData,
                ref queryRoleRes.UnimportanceData,
                ref dropres.DropRateData,
                out firebasePushId,
                out realmId);

            if (bsuccess)
            {
                queryRoleRes.Ret = 0;

                TraceLog.Debug("OnQueryRoleReq query role success, uid {0}  level {1} exp {2}",
                    queryRoleRes.RoleBase.Uid, queryRoleRes.RoleBase.Level, queryRoleRes.RoleBase.Exp);

                //queryRoleRes.GameId = queryRoleReq.GameId;
                queryRoleRes.Realm = queryRoleReq.Realm;

                if (firebasePushId != null)
                {
                    queryRoleRes.FirebasePushId.SetString(firebasePushId);
                }
            }
            else
            {
                if (queryRoleReq.NoCreate == 1)
                {
                    TraceLog.Debug("OnQueryRoleReq no role record, no need create");
                    queryRoleRes.Ret = -1;
                    GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID,
                        (int)SSGameMsgID.QueryRoleDbRes, ref queryRoleRes, packet.ObjectID, packet.ServerID);
                    return;
                }

                //没有记录，则创建,大部分手游只有一个玩家角色信息（棋牌，卡牌，竞技游戏等等），直接创建user
                TraceLog.Debug("OnQueryRoleReq no role record, create it ");

                ref var roleBase = ref queryRoleRes.RoleBase;
                roleBase.Clear();
                roleBase.Uid = queryRoleReq.Uid;
                roleBase.Gender = 0;
                roleBase.Exp = 0;
                roleBase.Level = 1;
                roleBase.VipLevel = 0;
                roleBase.VipExp = 0;
                roleBase.Lang.SetString(queryRoleReq.LangOnCreate.GetPtr());

                roleBase.Chip = 0;
                roleBase.Diamond = 0;

                roleBase.CreateTime = GameDBServerUtils.GetTimeSecond();
                roleBase.LastLoginTime = GameDBServerUtils.GetTimeSecond();
                roleBase.OnlineTime = 0;

                ref var roleData = ref queryRoleRes.RoleData;
                roleData.Clear();
                roleData.LoginCount = 0;
                var talentPage = new DbTalentPageData { PageIndex = 0 };
                roleData.Talent.TalentPage.CopyFrom(ref talentPage);
                var peakPage = new DbTalentPageData { PageIndex = 1};
                roleData.Talent.PeakData.CopyFrom(ref peakPage);
                roleData.Talent.TalentPage.Point = 1;

                ref var unimportanceData = ref queryRoleRes.UnimportanceData;
                unimportanceData.Clear();
                unimportanceData.MagicNum = 123456789;

                ref var dropRateData = ref dropres.DropRateData;
                dropRateData.Clear();
                bool bSuccess = dbOperator.InsertRole(
                    queryRoleReq.Realm,
                    ref roleBase,
                    ref roleData,
                    ref unimportanceData,
                    ref dropRateData);

                if (!bSuccess)
                {
                    queryRoleRes.Ret = -1;
                    TraceLog.Error("OnQueryRoleReq uid {0} insert role failed!", roleBase.Uid);
                }
                else
                {
                    TraceLog.Debug("OnQueryRoleReq uid {0} insert role success", roleBase.Uid);

                    queryRoleRes.Ret = 0;
                    //queryRoleRes.GameId = queryRoleReq.GameId;
                    queryRoleRes.Realm = queryRoleReq.Realm;
                    queryRoleRes.IsFirstCreate = 1;
                }
            }

            GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID,
                (int)SSGameMsgID.QueryRoleDbRes, ref queryRoleRes, packet.ObjectID, packet.ServerID);
            GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID,
               (int)SSGameMsgID.QueryRoleDropDbRes, ref dropres, packet.ObjectID, packet.ServerID);
        }
        
        public static void OnSaveRoleReq(uint remoteAppID, StructPacket packet, GameDBOperator dbOperator)
        {
            ref SSSaveRoleReq saveRoleReq = ref packet.GetMessage<SSSaveRoleReq>();

            TraceLog.Debug("OnSaveRoleReq uid {0} dataSeq {1}"
                , saveRoleReq.RoleBase.Uid, saveRoleReq.DataSeq);

            SSSaveRoleRes saveRoleRes = new SSSaveRoleRes();
            saveRoleRes.DataSeq = saveRoleReq.DataSeq;
            saveRoleRes.Uid = saveRoleReq.RoleBase.Uid;
            saveRoleRes.Logout = saveRoleReq.Logout;
            saveRoleRes.GameServerID = saveRoleReq.GameServerID;
            saveRoleRes.Ret = -1;

            bool bSuccess = dbOperator.UpdateRole(ref saveRoleReq.RoleBase,
                ref saveRoleReq.RoleData,
                ref saveRoleReq.UnimportanceData,ref saveRoleReq.DropRateData);
            if (!bSuccess)
            {
                saveRoleRes.Ret = -1;

                TraceLog.Error("OnSaveRoleReq uid {0} dataSeq {1} save failed!"
                    , saveRoleReq.RoleBase.Uid, saveRoleReq.DataSeq);
            }
            else
            {
                saveRoleRes.Ret = 0;
            }

            TraceLog.Debug("OnSaveRoleReq uid {0} dataSeq {1} ret {2}"
                , saveRoleReq.RoleBase.Uid, saveRoleReq.DataSeq, saveRoleRes.Ret);

            GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID,
                (int)SSGameMsgID.SaveRoleRes, ref saveRoleRes, packet.ObjectID);
        }

        public static void OnFirebaseidSaveDbReq(uint remoteAppID, StructPacket packet, GameDBOperator dbOperator)
        {
            ref SSFirebaseidSaveDbReq req = ref packet.GetMessage<SSFirebaseidSaveDbReq>();

            TraceLog.Debug("OnFirebaseidSaveDbReq uid {0} firebaseId {1}"
                , packet.ObjectID, req.FirebasePushId);

            bool bSuccess = dbOperator.UpdateRoleFirebasePushId(packet.ObjectID, req.FirebasePushId.GetString());
            if (!bSuccess)
            {
                TraceLog.Error("OnFirebaseidSaveDbReq uid {0} firebaseId {1} save failed!"
                    , packet.ObjectID, req.FirebasePushId);
            }
            else
            {
                TraceLog.Debug("OnFirebaseidSaveDbReq uid {0} dataSeq {1} success"
                    , packet.ObjectID, req.FirebasePushId);
            }
        }

        public static void OnFirebaseidQueryDbReq(uint remoteAppID, StructPacket packet, GameDBOperator dbOperator)
        {
            ref var req = ref packet.GetMessage<SSFirebaseidQueryDbReq>();

            TraceLog.Debug("OnFirebaseidQueryDbReq uid {0} seq {1}", packet.ObjectID, req.PushReqSeq);

            string firebaseId = dbOperator.QueryRoleFirebaseId(packet.ObjectID);

            SSFirebaseidQueryDbRes res = new SSFirebaseidQueryDbRes();

            res.PushReqSeq = req.PushReqSeq;

            if(firebaseId != null)
            {
                res.PushId.SetString( firebaseId);
            }

            TraceLog.Debug("OnFirebaseidQueryDbReq uid {0} dataSeq {1} firebaseId {2}"
                , packet.ObjectID, req.PushReqSeq, firebaseId);

            GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID,
                (int)SSGameMsgID.FirebaseidQueryDbRes, ref res, packet.ObjectID);
        }

        public static void OnSetFreezeTime(uint remoteAppID, StructPacket packet, GameDBOperator dbOperator)
        {
            ref var req = ref packet.GetMessage<SSGMSetFreezeTime>();

            TraceLog.Debug("OnSetFreezeTime uid {0} time {1} reasonTtpe: {2} reasonstr: {3};", req.Uid, req.FreezeTime, req.FreezeReason, req.FreezeReasonStr.GetString());

            bool bSuccess = dbOperator.SetFreezeTime(req.Uid, req.FreezeTime, (int)req.FreezeReason, req.FreezeReasonStr.GetString());

			SSGMSetFreezeTimeRes res = new SSGMSetFreezeTimeRes();
            res.FreezeTime = req.FreezeTime;
            res.FromServerID = req.FromServerID;
            res.Uid = req.Uid;
            res.OpId = req.OpId;
            res.FreezeReason = req.FreezeReason;
            res.FreezeReasonStr = req.FreezeReasonStr;
            res.Ret = bSuccess ? 0 : -1;
            res.OpSource.SetString(req.OpSource.ToString());

            TraceLog.Debug("OnSetFreezeTime uid {0} FreezeTime {1} fromserverid {2} ret {3} FreezeReason {4} FreezeReasonStr {5} OpSource {6}"
                , req.Uid, req.FreezeTime, req.FromServerID, res.Ret, (int)req.FreezeReason, req.FreezeReasonStr.GetString(), req.OpSource.GetString());

            GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID,
                (int)SSGameMsgID.GmSetFreezeTimeRes, ref res, packet.ObjectID);
		}

		public static void OnPlayerQueryOfflineRoleReq(uint remoteAppID, StructPacket packet, GameDBOperator dbOperator)
		{
			ref SSPlayerQueryOfflineRoleReq queryRoleReq = ref packet.GetMessage<SSPlayerQueryOfflineRoleReq>();

			SSPlayerQueryOfflineRoleRes queryRoleRes = new SSPlayerQueryOfflineRoleRes();
			queryRoleRes.Ret = CSErrCode.None;
			queryRoleRes.CallBackReq.CopyFrom(ref queryRoleReq);
			queryRoleRes.TargetIsOnline = false;

            int realmId;
            bool bsuccess = dbOperator.QueryOfflineRole(queryRoleReq.TargetUid, ref queryRoleRes.RoleBase, ref queryRoleRes.RoleData, out realmId);

			if (bsuccess == false)
			{
				queryRoleRes.Ret = CSErrCode.TargetNotExist;
			}
            queryRoleRes.TargetRealmId = realmId;
            GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID,
				(int)SSGameMsgID.PlayerQueryOfflineRoleRes, ref queryRoleRes, packet.ObjectID);
		}

	    public static void OnPlayerSearchRoledbBynameReq(uint remoteAppID, StructPacket packet, GameDBOperator dbOperator)
	    {
		    ref SSPlayerSearchRoleDBByNameReq queryRoleReq = ref packet.GetMessage<SSPlayerSearchRoleDBByNameReq>();


		    SSPlayerSearchRoleDBByNameRes queryRoleRes = new SSPlayerSearchRoleDBByNameRes();
		    queryRoleRes.Ret = CSErrCode.None;
		    queryRoleRes.FromUid = queryRoleReq.FromUid;


		    //创建结构体发往DB服务器
	        int myRealm = queryRoleReq.FromRealm;//;AccountUtils.GetRealmIdFromUserId(queryRoleReq.FromUid);

            StringBuilder text = new StringBuilder(" realm  = " + myRealm);
		    for (int i = 0; i < queryRoleReq.TargetName.Length; i++)
		    {
			    if (queryRoleReq.TargetName[i] == ' ')
			    {
				    continue;
			    }
			    text.Append(" and nick like '%" + queryRoleReq.TargetName[i] + "%'");
		    }

			dbOperator.SearchRoleByName(queryRoleReq.FromUid, text.ToString(), ref queryRoleRes);

		    

		    GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID,
			    (int)SSGameMsgID.PlayerSearchRoledbBynameRes, ref queryRoleRes, packet.ObjectID);
	    }
	
        public static void OnHandleEnableMsg(uint remoteAppID, StructPacket packet, GameDBOperator dbOperator)
        {
            ref SSEnableSendMsgReq req = ref packet.GetMessage<SSEnableSendMsgReq>();

            if (req.Uid == 0 || req.EnableTime == 0)
            {
                TraceLog.Error("RoleOp.OnHandleEnableMsg:");
                return;
            }

            SSEnableSendMsgRes res = new SSEnableSendMsgRes();
            res.Uid = req.Uid;
            res.EnableTime = req.EnableTime;
            res.ReasonType = req.ReasonType;
            res.FreezeReasonStr.SetString(req.FreezeReasonStr.ToString());
            res.OpSource.SetString(req.OpSource.ToString());

            if (!dbOperator.SetEnableMsgTime(req.Uid, req.EnableTime))
            {
                res.Ret = 1;
            }

            GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID,
                (int)SSGameMsgID.EnableSendMsgRes, ref res, packet.ObjectID);

        }

        public static void OnCostBagItem(uint remoteAppID, StructPacket packet, GameDBOperator dbOperator)
        {
            SSOperationCostItemReq req = packet.GetMessage<SSOperationCostItemReq>();
            //SSGmQueryUserRoletInfoRes queryRoleRes = new SSGmQueryUserRoletInfoRes();
            queryRoleRes.Clear();
            string firebasePushId = null;
            int realmId = 0;
            
            bool bsuccess = dbOperator.QueryRole(req.Uid,
                 ref queryRoleRes.RoleBase,
                 ref queryRoleRes.RoleData,
                 ref queryRoleRes.UnimportanceData,
                 ref queryRoleRes.DropRateData,
                 out firebasePushId,
                 out realmId);

            var itemId = req.ItemId.GetString();
            var itemIntId = ItemDescMgr.Instance.GetConfig(itemId).InternalId;
            int value = req.CostNum;
            SSOperationCostItemRes res = new SSOperationCostItemRes();
            if (queryRoleRes.RoleBase.Uid == 0)
            {
                res.Id = req.Id;
                res.Ret = -1;
                GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID, (int)SSGameMsgID.OperationCostItemRes, ref res, packet.ObjectID, packet.ServerID);
                return;
            }
            ref var pandoraBag = ref queryRoleRes.RoleData.PandoraBag;
            var index = -1;
            for (int i = 0; i < pandoraBag.ItemList.Count; i++)
            {
                if (pandoraBag.ItemList[i].Id  == itemIntId)
                {
                    index = i;
                    break;
                }
            }

            var num = index < 0 ? 0 : pandoraBag.ItemList[index].Count;
            num += value;
            if (index < 0)
            {
                pandoraBag.ItemList.Add(new DBBagItem(){Id = itemIntId, Count = num} );
            }
            else
            {
                pandoraBag.ItemList[index].Count = Math.Max(num, 0);
            }
           
            bool bSuccess = dbOperator.UpdateRole(ref queryRoleRes.RoleBase, ref queryRoleRes.RoleData, ref queryRoleRes.UnimportanceData,ref queryRoleRes.DropRateData);
            if (!bSuccess)
            {
                queryRoleRes.Ret = -1;
                TraceLog.Error("cost item error,uid={0},itemId={1}", req.Uid, itemId);
            }
            res.Id = req.Id;
            res.Ret = queryRoleRes.Ret;
            GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID, (int)SSGameMsgID.OperationCostItemRes, ref res, packet.ObjectID, packet.ServerID);
        }
        
        public static void OnDoneTask(uint remoteAppID, StructPacket packet, GameDBOperator dbOperator)
        {
            SSOperationUpdateTaskReq req = packet.GetMessage<SSOperationUpdateTaskReq>();
            //SSGmQueryUserRoletInfoRes queryRoleRes = new SSGmQueryUserRoletInfoRes();
            queryRoleRes.Clear();
            string firebasePushId = null;
            int realmId = 0;
            bool bsuccess = dbOperator.QueryRole(req.Uid,
                ref queryRoleRes.RoleBase,
                ref queryRoleRes.RoleData,
                ref queryRoleRes.UnimportanceData,
                ref queryRoleRes.DropRateData,
                out firebasePushId,
                out realmId);

            int taskId = req.TaskId;
            SSOperationUpdateTaskRes res = new SSOperationUpdateTaskRes();
            if (queryRoleRes.RoleBase.Uid == 0)
            {
                res.Id = req.Id;
                res.Ret = -1;
                GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID, (int)SSGameMsgID.OperationUpdateTaskRes, ref res, packet.ObjectID, packet.ServerID);
                return;
            }
            ref var taskList = ref queryRoleRes.RoleData.TaskEXData.TaskList;
            int index = -1;
            for (int i = 0; i < taskList.Count; i++)
            {
                if (taskList[i].TaskId == taskId && taskList[i].Status == (int)TaskEXCfg.TaskStatusProcessing)
                {
                    index = i;
                    break;
                }
            }
            if (index == -1)
            {
                res.Ret = -1;
                GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID, (int)SSGameMsgID.OperationUpdateTaskRes, ref res, packet.ObjectID, packet.ServerID);
                return;
            }
            ref var task = ref taskList[index];
            task.Status = (int)TaskEXCfg.TaskStatusComplete;
            var desc = QuestEXDescMgr.Instance.GetConfig(taskId);
            ref var condition = ref task.Condition;
            for (int i = 0; i < desc.fulfill.Length; i++)
            {
                var cd = desc.fulfill[i].Condition;
                for (int j = 0; j < Math.Min(cd.Length, condition.Count); j++)
                {
                    condition[j].CurrVal = (int)cd[j];
                    condition[j].Done = true;
                }
            }
            bool bSuccess = dbOperator.UpdateRole(ref queryRoleRes.RoleBase, ref queryRoleRes.RoleData, ref queryRoleRes.UnimportanceData,ref queryRoleRes.DropRateData);
            if (!bSuccess)
            {
                queryRoleRes.Ret = -1;
            }
            res.Id = req.Id;
            res.Ret = queryRoleRes.Ret;
            GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID, (int)SSGameMsgID.OperationUpdateTaskRes, ref res, packet.ObjectID, packet.ServerID);
        }


        public static void OnGmUpdateRoleData(uint remoteAppID, StructPacket packet, GameDBOperator dbOperator)
        {
            SSGmUpdateUserRoleInfoReq req = packet.GetMessage<SSGmUpdateUserRoleInfoReq>();

            //SSGmQueryUserRoletInfoRes queryRoleRes = new SSGmQueryUserRoletInfoRes();
            queryRoleRes.Clear();
            SSGmUpdateUserRoleInfoRes res = new SSGmUpdateUserRoleInfoRes();
            res.Id = req.Id;
            string firebasePushId = null;
            int realmId = 0;
            bool bsuccess = dbOperator.QueryRole(req.Uid,
                ref queryRoleRes.RoleBase,
                ref queryRoleRes.RoleData,
                ref queryRoleRes.UnimportanceData,
                ref queryRoleRes.DropRateData,
                out firebasePushId,
                out realmId);
            if (!bsuccess)
            {
                res.Ret = -1;
                GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID, (int)SSGameMsgID.GmUpdateUserRoleRes,
                    ref res, packet.ObjectID, packet.ServerID);
            }

            if (queryRoleRes.RoleBase.Uid == 0)
            {
                res.Ret = -1;
                GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID, (int)SSGameMsgID.GmUpdateUserRoleRes,
                    ref res, packet.ObjectID, packet.ServerID);
                return;
            }

            var successful = UpdateRoleData(req, ref queryRoleRes.RoleData);
            if (!successful)
            {
                res.Ret = -1;
                GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID, (int)SSGameMsgID.GmUpdateUserRoleRes,
                    ref res, packet.ObjectID, packet.ServerID);
                return;
            }

            var bSuccess = dbOperator.UpdateRole(ref queryRoleRes.RoleBase, ref queryRoleRes.RoleData,
                ref queryRoleRes.UnimportanceData, ref queryRoleRes.DropRateData);
            if (!bSuccess)
            {
                queryRoleRes.Ret = -1;
            }

            res.Ret = queryRoleRes.Ret;
            GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID, (int)SSGameMsgID.GmUpdateUserRoleRes,
                ref res, packet.ObjectID, packet.ServerID);
        }

        public static void OnGmImportRoleData(uint remoteAppID, StructPacket packet, GameDBOperator dbOperator)
        {
            var req = packet.GetMessage<SSGmImportUserRoleInfoReq>();

            //var queryRoleRes = new SSGmQueryUserRoletInfoRes();
            queryRoleRes.Clear();
            var res = new SSGmImportUserRoleInfoRes();
            res.Id = req.Id;
            string firebasePushId = null;
            int realmId = 0;
            bool bsuccess = dbOperator.QueryRole(req.Uid,
                ref queryRoleRes.RoleBase,
                ref queryRoleRes.RoleData,
                ref queryRoleRes.UnimportanceData,
                ref queryRoleRes.DropRateData,
                out firebasePushId,
                out realmId);
            if (!bsuccess)
            {
                res.Ret = -1;
                GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID, (int)SSGameMsgID.GmImportUserRoleRes,
                    ref res, packet.ObjectID, packet.ServerID);
            }

            if (queryRoleRes.RoleBase.Uid == 0)
            {
                res.Ret = -1;
                GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID, (int)SSGameMsgID.GmImportUserRoleRes,
                    ref res, packet.ObjectID, packet.ServerID);
                return;
            }
            
            var bSuccess = dbOperator.UpdateRole(ref req.Data.RoleBase, ref  req.Data.RoleData,
                ref  req.Data.UnimportanceData, ref  req.Data.DropRateData);
            if (!bSuccess)
            {
                queryRoleRes.Ret = -1;
            }

            res.Ret = queryRoleRes.Ret;
            GameDBServerUtils.GetPacketSender().SendToServerByID(remoteAppID, (int)SSGameMsgID.GmImportUserRoleRes,
                ref res, packet.ObjectID, packet.ServerID);
        }

        private static bool UpdateRoleData(SSGmUpdateUserRoleInfoReq req, ref DBRoleData roleData)
        {
            var newValue = req.NewValue.GetString();
            string sub = req.SubFieldPath.GetString();
            sub = sub.Substring(0, sub.Length - 1);
            var subNameList = sub.Split(".");
            if (subNameList.Length == 0)
            {
                return false;
            }

            if (sub.Contains("["))
            {
                RoleDataHelper.UpdateExistArrayData(ref roleData, subNameList, newValue);
                return true;
            }
            //路径中没有数组
            RoleDataHelper.UpdateNoArrayData(ref roleData, subNameList, newValue);
            return true;
        }
    }
}