local ipairs = ipairs
  local table = table
  local math = math
  local next = next
  local string = string
  local redisproxy = redisproxy
  local MsgPack = MsgPack
  local getRandomName = getRandomName
  local mcast_util = mcast_util
  local string_format = string.format
  local tonumber = tonumber
  local require = require
  local table_insert = table.insert
  local tconcat = table.concat
  local table_unpack = table.unpack
  

  local AdvCommon = require "adv.AdvCommon"
  

  local _M = {}
  

  -- 无尽模式是否开放
  local function isOpenEndless(role)
  	if role.advOverTime ~= 0 and skynet.timex() >= role.advOverTime then
  		return false
  	end
  	return true
  end
  -- 冒险内的操作是否可以继续
  local function isCanContinue(role)
  	local adv = role:getAdvData()
  	if not adv:isRunning() then return false end
  	if adv:isEndless() then
  		if not isOpenEndless(role) then return false end
  	end
  	return true
  end
  

  local function checkFormat(role, format, checkAdvTeam)

  	local advHang = role:getProperty("advHang")
  	local hadHero = {}
  	for chapterId, info in pairs(advHang) do
  		if info.format then
  			for _, heroId in pairs(info.format.heros) do
  				hadHero[heroId] = true
  			end
  		end
  	end
  

  	if checkAdvTeam then

  		for _, heroId in pairs(role:getProperty("advTeam").heros or {}) do
  			hadHero[heroId] = true
  		end
  	end
  
  	if not format.leader then return end

  	if format.leader2 == format.leader then return end

  	local hadLeader = false

  	local hadLeader2 = false
  	local heroCount = 0

  	for slot, heroId in pairs(format.heros) do
  		if not role.heros[heroId] or hadHero[heroId] then
  			return
  		end
  		if heroId == format.leader then
  			hadLeader = true
  		end

  		if heroId == format.leader2 then
  			hadLeader2 = true
  		end
  		heroCount = heroCount + 1
  	end
  	if not hadLeader2 and heroCount >= 2 then
  		return

  	end
  	if not hadLeader then return end
  	return true
  end
  

  --开始一个新的关卡

  function _M.startAdvRpc( agent, data )
  	local role = agent.role
  	local msg = MsgPack.unpack(data)

  	local chapterId = msg.chapterId --关卡id
  	local layer = msg.layer or 1	--选择层数
  	local format = msg.format 		--编队

  	local supportIdx = msg.supportIdx --选择的支援效果

  	if not role:isFuncUnlock(FuncUnlock.Adv) then return end
  	

  	--上一个关卡结束才可以开始新的关卡

  	if role:getAdvData():isRunning() then return 8 end

  	local advHang = role:getProperty("advHang")

  	-- if advHang[chapterId] then return 9 end --正在挂机

  	local chapterData = csvdb["adv_chapterCsv"][chapterId]

  	if not chapterData or layer < 1 then return  1 end

  	local advPass = role:getProperty("advPass")

  
  	if AdvCommon.isEndless(chapterId) then -- 无尽模式判断
  

  		if chapterId ~= role.advElChapter then return end -- 不是当前进行的章节
  		if not isOpenEndless(role) then return end

  		if role.dailyData:getProperty("advElC") >= role:getAdvElLimit() then return 2 end -- 是否有体力

  		if not role:isFuncOpen(FuncOpenType.AdvEndless) then return 11 end -- 无尽模式 才可以玩儿无尽模式
  
  		local advElM = role:getProperty("advElM")  --最高通关的层数

  		if not role:advChapterIsOpen(chapterId) then return 13 end

  		if layer ~= 1 then

  			local relayData = role:getAdvData():isHaveRelay(layer, chapterId) 

  			if not relayData then return 14 end  -- 不是中继层
  			if advElM < relayData.unlockfloor then return 15 end --未解锁

  		end 

  	else   -- 普通模式判断

  		if not role:checkAdvCount(chapterData.limitlevel) then return 2 end -- 是否有体力

  		if layer >= chapterData.limitlevel  then return 4 end

  		-- 关卡开放判断

  		if not role:advChapterIsOpen(chapterId) then return 5 end
  
  		if layer ~= 1 then
  			local relayData = role:getAdvData():isHaveRelay(layer, chapterId) 
  			if not relayData then return 6 end  -- 不是中继层
  			if (advPass[chapterId] or 0) < relayData.floor then return 21 end
  		end

  	end

  	
  	if not checkFormat(role, format) then return 7 end

  	local advTeam = role:getProperty("advTeam")
  	table.clear(advTeam)
  
  	advTeam.heros = {}

  	for slot, heroId in pairs(format.heros) do

  		advTeam.heros[slot] = heroId
  	end

  	advTeam.leader = format.leader

  	advTeam.leader2 = format.leader2

  	role:updateProperty({field = "advTeam", value = advTeam})

  	if AdvCommon.isEndless(chapterId) then
  		role.dailyData:updateProperty({field = "advElC", delta = 1})
  	else

  		role:changeAdvCount(chapterData.limitlevel)

  	end

  	local support = {}  -- 支援效果
  	if AdvCommon.isEndless(chapterId) then
  		-- 选择的支援效果
  		local advSup = role:getProperty("advSup")
  		if supportIdx then
  			if advSup[supportIdx] then
  				table.insert(support, advSup[supportIdx])
  			end
  			role:advRandomSupportEffect() -- 选完就重新随机
  		end
  		-- 增加 默认增加的支援效果
  		local active = role:getAdvActiveSupportEffect()
  		for aId, _ in pairs(active) do
  			local curData = csvdb["adv_supportCsv"][aId]
  			if curData.type == 2 then
  				table.insert(support, aId)
  			end
  		end
  	end

  	role:getAdvData():initByChapter({
  		chapterId = chapterId, 
  		level = layer, 
  		isRelay = layer ~= 1, 
  		isEnter = true, 
  		support = support,
  	})

  	role:checkTaskEnter("AdvStart", {id = chapterId})

  	role:checkTaskEnter("AdvStartSelf", {id = chapterId})

  	role:getAdvData():popBackEvents() -- 清一下事件

  	role:getAdvData():mylog({desc = "start", int1 = supportIdx})

  	SendPacket(actionCodes.Adv_startAdvRpc, '')
  	return true
  end

  
  function _M.startHangRpc(agent, data)

  	local role = agent.role
  	local msg = MsgPack.unpack(data)

  	local chapterId = msg.chapterId --关卡id

  	local campId = msg.campId or 2 --营地id

  	local format = msg.format --编队

  	local index = msg.index or 1--时间索引id

  	local chapterData = csvdb["adv_chapter_campsiteCsv"][chapterId]

  	if not chapterData then return 1 end

  	local campSiteData = chapterData[campId]
  	if not campSiteData then return 1 end
  	if campSiteData.idleReward_1 == "" and campSiteData.idleReward_2 == "" then return 2 end --没有奖励 没有挂机
  
  	local adv_idle_time = globalCsv.adv_idle_time[index]
  	local adv_idle_energy = globalCsv.adv_idle_energy[index]
  	local adv_idle_reward_coef = globalCsv.adv_idle_reward[index]
  	if not adv_idle_time or not adv_idle_energy or not adv_idle_reward_coef then
  		return 2
  	end

  	adv_idle_time = adv_idle_time * 60

  
  	local advHang = role:getProperty("advHang")

  	if advHang[chapterId] then return 3 end --正在挂机

  	-- if role:getAdvData():isRunning() and role:getAdvData().chapterId == chapterId then return 4 end

  	if AdvCommon.isEndless(chapterId) then return 5 end -- 无尽没有代理

  	local advRelay = role:getProperty("advRelay") 

  	if not next(advRelay[chapterId] or {}) then return 6 end -- 没有开放

  	if not role:checkAdvCount(adv_idle_energy) then return 7 end -- 是否有体力

  	if not checkFormat(role, format, role:getAdvData():isRunning()) then return 8 end --编队是否正确

  	local player = {}
  	local attrs = role:getTeamBattleInfo(format).heros
  	for attrName, _ in pairs(AdvAttsEnum) do
  		for _, hero in pairs(attrs) do
  			player[attrName] = (player[attrName] or 0) + hero[attrName]
  		end
  		player[attrName] = player[attrName] * (globalCsv.adv_battle_attr_ratio[attrName] or 1)

  	end

  
  	local battleV = 1 * player["hp"]
  		+ 2 * player["atk"]
  		+ 1.25 * player["def"]
  		+ 0.226 * player["hit"]
  		+ 0.26 * player["miss"]
  

  	if battleV < campSiteData.idleValue then return 9 end -- 战斗力是否满足

  
  	local info = {}
  	info.format = {}
  	info.format.leader = format.leader

  	info.format.leader2 = format.leader2

  	info.format.heros  = {}
  	for slot, heroId in pairs(format.heros) do
  		info.format.heros[slot] = heroId
  	end

  	info.time = skynet.timex() + adv_idle_time --挂机时间
  	info.campId = campId
  	info.index = index

  	-- 没有在战斗  用team来挂机了  把team清掉

  	if not role:getAdvData():isRunning() then
  		role:updateProperty({field = "advTeam", value = {}})
  	end

  	role:pushMsg({type = "adv", slot = chapterId, time = adv_idle_time})

  	role:changeUpdates({{type = "advHang", field = chapterId, value = info}})
  

  	role:changeAdvCount(adv_idle_energy)

  	role:checkTaskEnter("AdvStart", {id = chapterId})

  	role:mylog("adv_action", {desc = "startHang", int1 = chapterId})

  	SendPacket(actionCodes.Adv_startHangRpc, '')
  	return true
  end
  

  function _M.quickHangRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  
  	local chapterId = msg.chapterId --关卡id
  	
  	local advHang = role:getProperty("advHang")
  	local info = advHang[chapterId]
  	if not info then return end 
  

  	local index = info.index
  	local chapterData = csvdb["adv_chapter_campsiteCsv"][chapterId]

  	if not chapterData then return end

  
  	local campSiteData = chapterData[info.campId]
  	if not campSiteData then return 1 end
  	if campSiteData.idleReward_1 == "" and campSiteData.idleReward_2 == "" then return 2 end --没有奖励 没有挂机
  
  	local adv_idle_time = globalCsv.adv_idle_time[index]
  	if not adv_idle_time then
  		return 2
  	end

  	adv_idle_time = adv_idle_time * 60

  	
  	local reward, isFull
  	if skynet.timex() >= info.time then return end  -- 已经完成了
  

  	local cost = math.ceil((info.time - skynet.timex()) / 3600 * globalCsv.adv_idle_quicken)

  
  	if not role:checkItemEnough({[ItemId.Diamond] = cost}) then return end

  	role:costItems({[ItemId.Diamond] = cost}, {log = {desc = "advQuickHang", int1 = chapterId}})

  	info.time = 0
  	role:changeUpdates({{type = "advHang", field = chapterId, value = info}})
  

  	role:pushCancel({type = "adv", slot = chapterId})

  	role:mylog("adv_action", {desc = "advQuickHang", int1 = chapterId})
  

  	SendPacket(actionCodes.Adv_quickHangRpc, '')
  	return true
  end
  

  function _M.endHangRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  
  	local chapterId = msg.chapterId --关卡id
  	local cancel = msg.cancel  --是否是取消
  	
  	local advHang = role:getProperty("advHang")
  	local info = advHang[chapterId]
  	if not info then return end 
  

  	local index = info.index or 1
  	local chapterData = csvdb["adv_chapter_campsiteCsv"][chapterId]

  	if not chapterData then return end

  	local campSiteData = chapterData[info.campId or 2]
  	if not campSiteData then return 1 end
  	if campSiteData.idleReward_1 == "" and campSiteData.idleReward_2 == "" then return 2 end --没有奖励 没有挂机
  
  	local adv_idle_time = globalCsv.adv_idle_time[index]
  	local adv_idle_energy = globalCsv.adv_idle_energy[index]
  	local adv_idle_reward_coef = globalCsv.adv_idle_reward[index]
  	if not adv_idle_time or not adv_idle_energy or not adv_idle_reward_coef then
  		return 2
  	end

  	adv_idle_time = adv_idle_time * 60

  	local reward, isFull, change

  	if skynet.timex() >= info.time then

  		-- 最新需求加成取消
  		--[[

  		-- 英雄加成
  		local idleUnit = chapterData.idleUnit:toNumMap()
  		local upUnit = 0

  		for slot, heroId in pairs((info.format or {}).heros or {}) do
  			local hero = role.heros[heroId]
  			if hero then
  				if idleUnit[hero:getProperty("type")] then
  					upUnit = upUnit + idleUnit[hero:getProperty("type")]
  				end

  			end
  		end
  		-- 中继加成
  		local advPass = role:getProperty("advPass")
  		local maxCampsite = nil
  		local campsiteCsv = csvdb["adv_chapter_campsiteCsv"][chapterId]
  		for _, campsite in ipairs(campsiteCsv) do
  			if campsite.floor <= advPass[chapterId] then
  				maxCampsite = campsite

  			else
  				break

  			end
  		end
  
  		if not maxCampsite then return end

  		]]
  		local totalReward = campSiteData.idleReward_1 .. " " .. campSiteData.idleReward_2

  		local idleReward = totalReward:toNumMap()

  		for itemId, count in pairs(idleReward) do

  			idleReward[itemId] = count * adv_idle_reward_coef

  		end

  		reward, change = role:award(idleReward, {log = {desc = "advHang", int1 = chapterId}})

  	else
  		if cancel then

  			--role:changeAdvCount(-chapterData.limitlevel)

  			-- if role:getProperty("advC") <= 0 then 
  			-- 	isFull = true
  			-- else
  			-- 	role:updateProperty({field = "advC", delta = -chapterData.limitlevel})
  			-- end

  			role:pushCancel({type = "adv", slot = chapterId})

  		else

  			return
  		end
  	end

  	
  	role:changeUpdates({{type = "advHang", field = chapterId, value = nil}})
  

  	role:mylog("adv_action", {desc = "endHang", int1 = chapterId, short1 = cancel and 1 or 0})
  

  	role:checkTaskEnter("AdvHang", {})
  

  	SendPacket(actionCodes.Adv_endHangRpc, MsgPack.pack({reward = reward, change = change, isFull = isFull}))

  	return true
  end
  
  function _M.buyAdvCountRpc(agent , data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	
  	local count = msg.count --购买次数

  	local isEl = msg.isEl -- 是否是无尽模式
  	local cost
  	if isEl then

  		if math.illegalNum(count, 1, globalCsv.adv_endless_daily_buy_count - role.dailyData:getProperty("advElBC")) then return end

  		cost = {[ItemId.Diamond] = count * globalCsv.adv_endless_daily_buy_cost}
  	else

  		if math.illegalNum(count, 1, globalCsv.adv_daily_buy_count - role.dailyData:getProperty("advBC")) then return end

  		cost = {[ItemId.Diamond] = count * globalCsv.adv_daily_buy_cost}
  	end
  	
  	

  	if not role:checkItemEnough(cost) then return end

  	role:costItems(cost, {log = {desc = "buyAdvCount", int1 = isEl and 1 or 0, int2 = count}})

  	if isEl then
  		role.dailyData:updateProperty({field = "advElC", delta = -count})
  		role.dailyData:updateProperty({field = "advElBC", delta = count})
  	else

  		role:changeAdvCount(-count * globalCsv.adv_daily_buy_num)

  		role.dailyData:updateProperty({field = "advBC", delta = count})
  	end

  	role:mylog("adv_action", {desc = "buyAdvCount", short1 = isEl and 1 or 0, int1 = count})

  	
  	SendPacket(actionCodes.Adv_buyAdvCountRpc, '')

  	return true
  end
  

  function _M.finishTaskRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  

  	if not isCanContinue(role) then return end

  	local adv = role:getAdvData()
  	local taskId = msg.taskId  -- -1 则是主线任务

  	local status, reward, change

  	if taskId == -1 then

  		status, reward, change = adv:finishMTask()

  	else
  		status, reward = adv:finishTask(taskId)

  		adv:checkAchievement(adv.AchievType.TaskLayer, 1, taskId)
  		adv:updateAchievement()

  	end

  	adv:updateTask()

  	if not status then return end

  	role:checkTaskEnter("AdvOverTask", {id = taskId})

  	adv:mylog({desc = "finishTask", int1 = taskId})

  	
  	role:log("mission_pick_achiev", {
  		mission_threadid = adv.chapterId, -- 大地图ID
  		mission_threadname = (csvdb["adv_chapterCsv"][adv.chapterId] or {})["chapter"] or "auto", -- 大地图名称
  		mission_id = adv.level, -- 关卡ID
  		mission_sequenceid = adv.logid, -- 本次拾荒ID，用于关联一次拾荒产生多条不同类型的日志
  		mission_pick_achiev_id = taskId, -- 任务ID
  		mission_pick_achiev_reward = reward, -- 任务奖励，[{"id":101,"num":10},{"id":102,"num":20},{"id":103,"num":30}]
  	})
  

  	SendPacket(actionCodes.Adv_finishTaskRpc, MsgPack.pack(role:packReward(reward, change)))

  	return true
  end
  

  -- 点击地块（解锁）(触发事件)
  function _M.clickBlockRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  

  	local function returnFail(status)
  		SendPacket(actionCodes.Adv_clickBlockRpc, MsgPack.pack({events = {}}))
  		return true or status -- 调试使用 status
  	end
  
  	if not isCanContinue(role) then
  		return returnFail()
  	end

  	local adv = role:getAdvData()

  	if adv:isWaitChooseArtifact() then return returnFail() end

  	adv:mylog({desc = "clickBlock", int1 = msg.roomId, int2 = msg.blockId})
  

  	local status, errorCode = adv:clickBlock(msg.roomId, msg.blockId, msg)

  	if not status then return returnFail(errorCode) end

  	SendPacket(actionCodes.Adv_clickBlockRpc, MsgPack.pack({events = adv:popBackEvents()}))
  	return true
  end
  
  --use item 使用背包道具
  function _M.useItemRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  

  	local itemId = msg.itemId -- 道具Id
  	local count = msg.count or 1 --数量
  	local target = msg.target -- {roomId = 1, blockId = 1} 选择的目标
  
  	local itemData = csvdb["adv_itemCsv"][itemId] 
  	if not itemData then return end
  

  	if not isCanContinue(role) then return end

  	local adv = role:getAdvData()

  	if adv:isWaitChooseArtifact() then return end

  	--重置数量 
  	if itemData["function"] == 0 or itemData["function"] == 2 then count = 1 end
  	if not adv:cost({[itemId] = count}, {}, true) then return true end
  

  	--消耗
  	if itemData["function"] == 0 or itemData["function"] == 1 then 

  		adv:cost({[itemId] = count}, {log = {desc = "useItem", int1 = itemId, int2 = count}})

  		adv:backUse({[itemId] = count})

  	end
  

  	if itemId == 5020 then
  		role:finishGuide(53)
  	end

  	adv:checkAchievement(adv.AchievType.UseItem, count, itemId)

  	adv:mylog({desc = "useItem", int1 = itemId, int2 = count})

  	role:log("mission_pick_use", {
  		mission_threadid = adv.chapterId, -- 大地图ID
  		mission_threadname = (csvdb["adv_chapterCsv"][adv.chapterId] or {})["chapter"] or "auto", -- 大地图名称
  		mission_id = adv.level, -- 关卡ID
  		item_id = itemId, -- 道具ID
  		mission_pick_use_num = count, -- 道具使用量
  		mission_sequenceid = adv.logid, -- 本次拾荒ID，用于关联一次拾荒产生多条不同类型的日志
  	})
  

  	for i = 1, count do
  		adv:doActive(itemData.effect, target) -- target
  	end
  	

  	adv:afterRound()
  	adv:saveDB()
  

  	SendPacket(actionCodes.Adv_useItemRpc, MsgPack.pack({events = adv:popBackEvents()}))
  	return true
  end
  

  --使用营养技能

  function _M.usePotionRpc(agent, data)

  	local role = agent.role
  	local msg = MsgPack.unpack(data)

  	local potionId = msg.potionId -- 营养剂Id
  	local target = msg.target -- {roomId = 1, blockId = 1} 选择的目标
  	local potionLv = role.dinerData:getProperty("dishTree"):getv(potionId, 0)
  	if potionLv == 0 then return 1 end
  
  	local potionSet = csvdb["adv_potionCsv"][potionId]
  	if not potionSet then return 2 end
  
  	local potionData = potionSet[potionLv]
  	if not potionData then return 3 end
  
  	local potionBag = role:getProperty("potionBag")
  	local own = potionBag[potionId] or 0
  	if own <= 0 then return 4 end

  
  	if not isCanContinue(role) then return end

  	local adv = role:getAdvData()

  	if adv:isWaitChooseArtifact() then return end
  

  	adv:mylog({desc = "usePotion", int1 = potionId})

  	local status = adv:doActive(potionData.effect, target) -- target

  	if not status then return end

  
  	potionBag[potionId] = own - 1
  	role:updateProperty({field = "potionBag", value = potionBag})

  	adv:pushBackEvent(AdvBackEventType.Potion, {id = potionId})

  	adv:afterRound()
  	adv:saveDB()
  	role:checkTaskEnter("AdvUsePotion")
  

  	role:finishGuide(61)
  

  	SendPacket(actionCodes.Adv_usePotionRpc, MsgPack.pack({events = adv:popBackEvents()}))

  	return true
  end

  -- 选择神器
  function _M.chooseArtifactRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)

  	if not isCanContinue(role) then return 1 end

  
  	local adv = role:getAdvData()

  	if not msg.idx then return 2 end
  	if not adv:isWaitChooseArtifact() then return 3 end

  	local status = adv:chooseArtifact(msg.idx)

  	if not status then return 4 end

  	adv:saveDB()

  	SendPacket(actionCodes.Adv_chooseArtifactRpc, '')
  	return true
  end
  
  -- 穿戴神器
  function _M.wearArtifactRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local slot = msg.slot
  	local id = msg.id
  

  	if not isCanContinue(role) then return end
  

  	local adv = role:getAdvData()
  

  	if math.illegalNum(slot, 1, 5) then return 1 end

  	if adv:isWaitChooseArtifact() then return 2 end

  
  	local status = adv:wearArtifact(slot, id)

  	if not status then return 3 end

  	adv:saveDB()
  

  	role:finishGuide(55)
  

  	SendPacket(actionCodes.Adv_wearArtifactRpc, '')
  	return true
  end
  
  -- 升级神器
  function _M.upArtifactRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local id = msg.id
  

  	if not isCanContinue(role) then return end
  

  	local adv = role:getAdvData()

  	if adv:isWaitChooseArtifact() then return 1 end

  	local curLevel = adv:isHaveArtifact(id)

  	if not curLevel then return 2 end
  	if not role:isArtifactOpen(id, adv:isEndless(), curLevel + 1) then return 3 end
  	local cost = csvdb["adv_artifactCsv"][id][curLevel].exp:toNumMap()
  	if not adv:cost(cost, {}, true) then return 4 end

  
  	local status = adv:artifactLevelUp(id)

  	if not status then 
  		return 5 
  	else
  		role:log("mission_pick_reform", {
  			mission_threadid = adv.chapterId, -- 大地图ID
  			mission_threadname = (csvdb["adv_chapterCsv"][adv.chapterId] or {})["chapter"] or "auto", -- 大地图名称
  			mission_id = adv.level, -- 关卡ID
  			mission_pick_equip_id = id, -- 神器ID
  			mission_pick_reform_beflv = curLevel, -- 神器原等级
  			mission_pick_reform_aftlv = curLevel + 1, -- 神器现等级
  			mission_pick_reform_cost = cost[ItemId.AdvPoint], -- 消耗探险点数
  			mission_sequenceid = adv.logid, -- 本次拾荒ID，用于关联一次拾荒产生多条不同类型的日志
  		})
  	end

  	adv:cost(cost, {log = {desc = "upArtifact", int1 = id}})

  	adv:backCost(cost)

  	if status == 1 then -- 现在穿着呢。更新下
  		adv:saveDB()

  	else
  		adv:updateAchievement()

  	end

  	SendPacket(actionCodes.Adv_upArtifactRpc, '')
  	return true
  end
  

  --退出
  function _M.exitAdvRpc(agent, data)
  	local role = agent.role
  	-- local msg = MsgPack.unpack(data)