local _M = {}
local redisproxy = redisproxy
function _M.clientRequest(agent, data)
	local msg = MsgPack.unpack(data)
	local role = agent.role
	local action = _M[msg.cmd]
	local bin = MsgPack.pack({ cmd = "指令失败" })
	if not action then
		SendPacket(actionCodes.Gm_receiveResponse, bin)
		return true
	end
	local ret = action(role, msg)
	bin = MsgPack.pack({ cmd = ret })
	SendPacket(actionCodes.Gm_receiveResponse, bin)
	return true
end

function _M.testhotfix(role, pms)
	return csvdb["itemCsv"][1]["name"] .. " -=- " .. globalCsv["codeVersion"] .. " -=- " .. role:getItemCount(123) .. " -=- " .. table.pack(next(role.heros))[2]:getBattleValue()
end

function _M.ignoreout(role, pms)
	pms = pms or {}
	local status = tonum(pms.pm1, 1)
	if status == 1 then  -- 忽视
		role:updateProperty({field = "ignoreMt", value = 1})
	else  -- 解除
		role:updateProperty({field = "ignoreMt", value = 0})
	end
	role:mylog("gm_action", {desc = "ignoreout", key1 = pms.sender})
	return "指令生效"
end

function _M.ban(role, pms)
	local now = skynet.timex()
	local time = tonum(pms.pm1, 1)
	local ctype = tonum(pms.pm2, 0)

	role:setBan(time, ctype)
	role:mylog("gm_action", {desc = "ban", int1 = time, int2 = ctype, key1 = pms.sender})
	return "封杀成功"
end


function _M.unban(role, pms)
	role:setBan(0, 0)
	role:setProperty("cheatCount", 0) -- 清除作弊次数
	role:mylog("gm_action", {desc = "unban", key1 = pms.sender})

	return "解封杀成功"
end

function _M.gmmsg(role, pms)
	role:sendGmMsg(pms.pm1, true)
	role:mylog("gm_action", {desc = "gmmsg", text1 = pms.pm1, key1 = pms.sender})
	return "指令成功"
end


function _M.reset_rank(role, pms)
	role:resetRank()
	role:mylog("gm_action", {desc = "reset_rank",  key1 = pms.sender})
	return "封杀成功"
end

function _M.silent(role, pms)
	local pm1 = tonum(pms.pm1)
	if pm1 < 1 then
		role:updateProperty({field = "silent", value = 0})
		return "解禁言成功"
	end
	role:updateProperty({field = "silent", value = specTime({hour = 0}, skynet.timex()) + pm1 * 86400})

	role:mylog("gm_action", {desc = "silent", int1 = pms.pm1, key1 = pms.sender})
	return "禁言成功"
end

function _M.pvp_cross_head(role, pms)
	role:awardExpireItem(tonum(pms.expire), pms.reward, {log = {desc = "pvpCHead"}})
	return "成功"
end

function _M.expire_item(role, pms)
	role:awardExpireItem(tonum(pms.pm1), pms.pm2, {log = {desc = "gm"}})
	return "成功"
end

local helpDes = {{"描述", "指令", "参数1", "参数2"	,"参数3"}}

table.insert(helpDes, {"获得角色"	, "hero", "角色类型"})
function _M.hero(role, pms)
	local heroType = tonum(pms.pm1)
	if not role:addHero({type = heroType, log = {desc = "gm"}}) then
		return "失败"
	end

	role:mylog("gm_action", {desc = "hero", int1 = heroType, key1 = pms.sender})
	return "成功"
end

table.insert(helpDes, {"角色升级"	, "herol", "角色类型", "增加等级"})
function _M.herol(role, pms)
	local heroType = tonum(pms.pm1)
	local addLevel = tonum(pms.pm2)
	local hero = role:isHaveHero(heroType)

	local MaxLv = 200

	if not hero then
		return "不存在的英雄类型"
	end
	if hero:getProperty("breakL") >= #csvdb["unit_breakCsv"] and hero:getProperty("level") >= MaxLv then
		return "等级已满"
	end
	local nextLevel = math.min(addLevel + hero:getProperty("level"), MaxLv)
	for i = 0, #csvdb["unit_breakCsv"] do
		local upLimit = csvdb["unit_breakCsv"][i].levelLimit
		local lowLimit = csvdb["unit_breakCsv"][i - 1] and csvdb["unit_breakCsv"][i - 1].levelLimit or 0
		if upLimit > nextLevel and lowLimit <= nextLevel then
			local addbl = i - hero:getProperty("breakL")
			if addbl > 0 then
				hero:updateProperty({field = "breakL", delta = addbl})
			end
		end
	end
	addLevel = math.min(hero:getMaxLevel() - hero:getProperty("level"), addLevel)
	hero:updateProperty({field = "level", delta = addLevel})
	role:checkTaskEnter("HeroLevelUp", {level = hero:getProperty("level")})

	role:mylog("gm_action", {desc = "herol", int1 = heroType, int2 = addLevel, key1 = pms.sender})

	return "成功"
end


table.insert(helpDes, {"全部角色升级"	, "herola", "增加等级"})
function _M.herola(role, pms)
	local addLevel = tonum(pms.pm1)
	for _, hero in pairs(role.heros) do
		_M.herol(role, {pm1 = hero:getProperty("type"), pm2 = addLevel})
	end

	role:mylog("gm_action", {desc = "herola", int1 = addLevel, key1 = pms.sender})

	return "成功"
end


table.insert(helpDes, {"获得装备"	, "equip", "装备类型"	, "装备等级", "装备个数"})
function _M.equip(role, pms)
	local typ = tonum(pms.pm1)
	local level = tonum(pms.pm2)
	local count = tonum(pms.pm3)
	role:addEquip(typ, level, count, {log = {desc = "gm"}})
	role:mylog("gm_action", {desc = "equip", int1 = typ, int2 = level, long1 = count, key1 = pms.sender})
	return "成功"
end

table.insert(helpDes, {"获得零件"	, "rune", "零件类型", "零件id"})
function _M.rune(role, pms)
	local typ = tonum(pms.pm1)
	local id = tonum(pms.pm2)
	local result = role:addRune({type = typ,id = id, log = {desc = "gm"}})
	role:mylog("gm_action", {desc = "rune", int1 = typ, int2 = id, key1 = pms.sender})

	return result
end

table.insert(helpDes, {"获得火花"	, "spark", "零件id"})
function _M.spark(role, pms)
	local id = tonum(pms.pm1)
	local result = role:addSpark({id = id, log = {desc = "gm"}})
	role:mylog("gm_action", {desc = "spark", int1 = id, key1 = pms.sender})

	return result == 0 and "成功" or "失败"
end

table.insert(helpDes, {"通关挂机副本", "fb", "挂卡id"})
function _M.fb(role, pms) -- 直接通关
	local carbonId = tonum(pms.pm1)
	if not csvdb["idle_battleCsv"][carbonId] then return "不存在的carbon" end
	local addPre 
	addPre = function(carbonId)
		local carbonData = csvdb["idle_battleCsv"][carbonId]
		for _, pre in ipairs(carbonData.prepose:toArray(true, "=")) do
			role:hangFinish(pre)
			role:checkTaskEnter("HangPass", {id = pre})
			addPre(pre)
		end
	end
	role:hangFinish(carbonId)
	addPre(carbonId)

	role:mylog("gm_action", {desc = "fb", int1 = carbonId, key1 = pms.sender})

	role:checkTaskEnter("HangPass", {id = carbonId})
	return "成功"
end

table.insert(helpDes, {"抵达挂机副本", "fbc", "副本id"})
function _M.fbc(role, pms) -- 直接通关
	local carbonId = tonum(pms.pm1)
	if not csvdb["idle_battleCsv"][carbonId] then return "不存在的carbon" end
	local passCarbon = {}
	local addPre 
	addPre = function(carbonId)
		local carbonData = csvdb["idle_battleCsv"][carbonId]
		for _, pre in ipairs(carbonData.prepose:toArray(true, "=")) do
			role:hangFinish(pre)
			role:checkTaskEnter("HangPass", {id = pre})
			addPre(pre)
		end
	end
	role:updateProperty({field = "hangPass", value = {}})
	addPre(carbonId)
	
	role:mylog("gm_action", {desc = "fbc", int1 = carbonId, key1 = pms.sender})

	return "成功"
end

-- table.insert(helpDes, {"好感度", "love", "角色类型", "好感度等级", "好感度经验"})
-- function _M.love(role, pms)
-- 	local heroType = tonum(pms.pm1)
-- 	local level = tonum(pms.pm2)
-- 	local exp = tonum(pms.pm3)
-- 	local curPlus = csvdb["unit_love_plusCsv"][heroType]
-- 	if not curPlus then return "参数错误" end
-- 	level = math.max(math.min(curPlus.limit, level), 0)
-- 	local curEffect = csvdb["unit_love_effectCsv"][level]
-- 	exp = math.max(math.min(curEffect.loveValue, exp) , 0)
-- 	for _, hero in pairs(role.heros) do
-- 		if hero:getProperty("type") == heroType then
-- 			hero:updateProperty({field = "loveL", value = level})
-- 			hero:updateProperty({field = "loveExp", value = exp})
-- 			if role:getProperty("loveStatus"):getv(heroType, 0) < level then
-- 				role:changeUpdates({{type = "loveStatus", field = heroType, value = level}}) -- 总的
-- 			end
-- 			role:checkTaskEnter("LoveBreak", {heroType = heroType, loveL = level})
-- 		end
-- 	end
-- 	return "成功"
-- end

table.insert(helpDes, {"玩家经验", "exp", "经验"})
function _M.exp(role, pms)
	local exp =  tonum(pms.pm1)
	exp = math.floor(math.max(exp, 0))
	role:addPlayExp(exp, {log = {desc = "gm"}})

	role:mylog("gm_action", {desc = "exp", int1 = exp, key1 = pms.sender})

	return "成功"
end

table.insert(helpDes, {"获得物品", "get", "物品ID", "个数"})
table.insert(helpDes, {"获得所有物品", "get", "ALL"})
table.insert(helpDes, {"获得所有装备", "get", "EQUIP"})
table.insert(helpDes, {"获得所有零件", "get", "RUNE"})
table.insert(helpDes, {"获得所有碎片", "get", "FRAG"})
table.insert(helpDes, {"获得所有食物", "get", "FOOD"})
table.insert(helpDes, {"获得所有角色", "get", "HERO"})
table.insert(helpDes, {"获得满级满觉醒角色,满级满精进铭文", "get", "MAXHERO"})
function _M.get(role, pms)
	if pms.pm1 == "ALL" then
		local reward = {}
		for id, data in pairs(csvdb["gm_getallCsv"]) do
			if csvdb["itemCsv"][id] then
				reward[id] = data.number
			end
		end
		role:award(reward, {log = {desc = "gm"}})
	elseif pms.pm1 == "EQUIP" then
		for itemId = 7000 , 8000 do
			if csvdb["itemCsv"][itemId] then
				role:award({[itemId] = 100}, {log = {desc = "gm"}})
			end
		end
	elseif pms.pm1 == "RUNE" then
		for itemId = 10000 , 20000 do
			if csvdb["itemCsv"][itemId] then
				role:award({[itemId] = 1}, {log = {desc = "gm"}})
			end
		end
	elseif pms.pm1 == "FRAG" then
		for itemId = 100 , 400 do
			if csvdb["itemCsv"][itemId] then
				role:award({[itemId] = 100}, {log = {desc = "gm"}})
			end
		end
	elseif pms.pm1 == "FOOD" then
		for itemId = 4000 , 5000 do
			if csvdb["itemCsv"][itemId] then
				role:award({[itemId] = 100}, {log = {desc = "gm"}})
			end
		end
	elseif pms.pm1 == "HERO" then
		for itemId = 400 , 700 do
			if csvdb["itemCsv"][itemId] then
				role:award({[itemId] = 1}, {log = {desc = "gm"}})
			end
		end
	elseif pms.pm1 == "MAXHERO" then
		-- 给英雄
		for heroId = 100, 500 do 
			local heroCfg = csvdb["unitCsv"][heroId]
			if heroCfg and heroCfg.open == 1 then
				role:award({[heroId + 300] = 1}, {log = {desc = "gm"}})
			end
		end
		-- 升满级
		for _, hero in ipairs(role.heros) do
			_M.herol(role, {pm1 = hero:getProperty("type"), pm2 = 130})
			hero:updateProperty({field = "wakeL", value = #csvdb["unit_wakeCsv"]})
		end

		-- 添加铭文
		for itemId = 10000 , 20000 do
			if csvdb["itemCsv"][itemId] then
				role:award({[itemId] = 1}, {log = {desc = "gm"}})
			end
		end
		for _, rune in ipairs(role.runeBag) do
			local typ = rune:getProperty("type")
			local id = rune:getProperty("id")

			local runeSet = csvdb["runeCsv"][typ]
			if not runeSet then break end
			local runeData = runeSet[id]
			if not runeData then break end

			rune:updateProperty({field = "level",value = runeData.lvLimit})
		end
	else
		local itemId = tonum(pms.pm1)
		if not csvdb["itemCsv"][itemId] then
			return "物品不存在"
		end
		local count = tonum(pms.pm2, 1)
		role:award({[itemId] = count}, {log = {desc = "gm"}})
		role:mylog("gm_action", {desc = "get", int1 = itemId, int2 = count, key1 = pms.sender})
	end
	return "成功"
end

table.insert(helpDes, {"冒险清除"	, "advc"})
function _M.advc(role, pms)
	local advTeam = role:getProperty("advTeam")
	advTeam.player = nil

	local reward = role:getProperty("advItems"):toNumMap()
	for itemId, count in pairs(reward) do
		reward[itemId] = math.ceil(count * globalCsv.adv_fail_reward_ratio / 100) -- 奖励相当于失败
	end
	role:award(reward, {log = {desc = "gm"}})

	role:updateProperties({
		advInfo = {}, 
		advTeam = advTeam,
		advItems = "",
		advAFGet = {},
		advAFWear = {},
	}, notNotify)
	role.advData = nil

	role:mylog("gm_action", {desc = "advc", key1 = pms.sender})

	return "成功"
end

table.insert(helpDes, {"冒险次数恢复", "advf"})
function _M.advf(role, pms)
	role:updateProperty({field = "advC", value = 0})
	role.dailyData:updateProperty({field = "advElC", value = 0})

	role:mylog("gm_action", {desc = "advf", key1 = pms.sender})

	return "成功"
end

table.insert(helpDes, {"冒险通关", "adv", "章节id", "层数"})
function _M.adv(role, pms)
	local chapterId = tonum(pms.pm1)
	local layer = tonum(pms.pm2)

	local advCsv = csvdb["adv_chapterCsv"][chapterId]
	if not advCsv then return "不存在的章节" end
	if math.floor(chapterId / 100) ~= 2 then
		layer = math.min(layer, advCsv.limitlevel)
	end
	local advPass = role:getProperty("advPass")

	if (advPass[chapterId] or 0) < layer then
		advPass[chapterId] = layer
		role:updateProperty({field = "advPass", value = advPass})
	end
	role:mylog("gm_action", {desc = "adv", int1 = chapterId, int2 = layer, key1 = pms.sender})

	return "成功"
end

table.insert(helpDes, {"冒险到达指定层", "advt", "章节id", "层数", "地图id(选)"})
function _M.advt(role, pms)
	local chapterId = tonum(pms.pm1)
	local layer = tonum(pms.pm2)
	local mapId = tonum(pms.pm3)
	local actid = tonum(pms.pm4)
	local advCsv = csvdb["adv_chapterCsv"][chapterId]
	if not advCsv then return "不存在的章节" end

	local status = _M.adv(role, {pm1 = chapterId, pm2 = layer - 1})
	if status ~= "成功" then return status end

	local advData = role:getAdvData()
	if advData:isRunning() then
		advData:forceOver()
	end

	advData:initByChapter({
		chapterId = chapterId, 
		level = layer, 
		isEnter = true,
		debugMapId = mapId,
		actid = actid,
	})
	role:mylog("gm_action", {desc = "advt", int1 = chapterId, int2 = layer, key1 = pms.sender})
	return "成功"
end

table.insert(helpDes, {"冒险队等级增加", "advl", "经验"})
function _M.advl(role, pms)
	local exp = tonum(pms.pm1)
	role:addAdvLvExp(math.max(0, exp))

	role:mylog("gm_action", {desc = "advl", int1 = exp, key1 = pms.sender})

	return "成功"
end

-- table.insert(helpDes, {"冒险内等级增加", "advcl", "经验值"})
-- function _M.advcl(role, pms)
-- 	local exp = tonum(pms.pm1)
-- 	local advData = role:getAdvData()

-- 	if not advData.chapterId then
-- 		return "先随便开启一关"
-- 	end
-- 	advData.battle.player:addExp(exp)
-- 	advData:saveDB()
-- 	role:mylog("gm_action", {desc = "advcl", int1 = exp, key1 = pms.sender})
		
-- 	return "成功"
-- end

table.insert(helpDes, {"挂机清除"	, "idlec"})
function _M.idlec(role, pms)
	role:updateProperty({field = "hangInfo", value = {}})
	role:updateProperty({field = "hangBag", value = {}})
	role:mylog("gm_action", {desc = "idlec", key1 = pms.sender})

	role.advData = nil
	return "成功"
end

table.insert(helpDes, {"冒险内可使用道具", "advit", "ALL"})
table.insert(helpDes, {"冒险内消耗道具", "advit", "itemId", "count"})
function _M.advit(role, pms)
	local reward = {}
	if pms.pm1 == "ALL" then
		for k, v in pairs(csvdb["adv_itemCsv"]) do
			if csvdb["itemCsv"][k] and v.effect ~= 0 then
				reward[k] = 1
			end
		end
		for k , v in pairs(csvdb["adv_artifactCsv"]) do
			if v[1].unlock == 0 then
				reward[k] = 1
			end
		end
	else
		local itemId = tonum(pms.pm1)
		local count = tonum(pms.pm2)
		reward[itemId] = count

		role:mylog("gm_action", {desc = "advit", int1 = itemId, int2 = count, key1 = pms.sender})
	end
	
	
	local adv = role:getAdvData()
	adv:award(reward, {log = {desc = "gm"}})
	return "成功"
end


table.insert(helpDes, {"爬塔到指定层", "tower", "塔id", "层数"})
function _M.tower(role, pms)
	local tType = tonum(pms.pm1, 1)
	local level = tonum(pms.pm2, 1)
	local layer = (tType - 1) * 10000 + level
	if not csvdb["tower_battleCsv"][level] then return  "不存在" end
	local values = role:getProperty("towerInfo")
	if tType == 1 then
		values.l = layer
	elseif tType == 2 then
		values.l1 = layer
	elseif tType == 3 then
		values.l2 = layer
	elseif tType == 4 then
		values.l3 = layer
	end
	role:updateProperty({field = "towerInfo", value = values})

	role:mylog("gm_action", {desc = "tower", int1 = tType, int2 = layer, key1 = pms.sender})

	return "成功"
end

table.insert(helpDes, {"发送邮件", "email", "id", "奖励"})
function _M.email(role, pms)
	local id = tonum(pms.pm1, 0)
	local reward = pms.pm2
	redisproxy:insertEmail({
		roleId = role:getProperty("id"), 
		emailId = id,
		createtime = skynet.timex(),
		title = id == 0 and "来自GM的邮件！" or nil, 
		stitle = id == 0 and "GM测试" or nil, 
		content = id == 0 and "测试内容测试内容！！！\n\t 巴拉巴拉！" or nil, 
		attachments = id == 0 and reward or nil,
		rewardPms = id ~= 0 and reward or nil,
	})

	role:mylog("gm_action", {desc = "email", int1 = id, key1 = pms.sender})

	return "成功"
end

table.insert(helpDes, {"引导", "guide", "skip/reset"})
function _M.guide(role, pms)
	local cmd = pms.pm1 or "un"
	if cmd == "SKIP" then
		role:updateProperty({field = "newerGuide", value = "9999=1"})
		local str = ""
		for _, set in pairs(csvdb["guide_mainCsv"]) do
			str = str:setv(set[1].major * 1000,1)
			for _,data in ipairs(set) do
				if data["break"] ~= 0 then
					str = str:setv(data.major * 1000 + data.minor,1)
				end
			end
		end
		for _, data in pairs(csvdb["guide_unlockCsv"]) do
			if data.type == 0 or data.type == 3 then
				str = str:setv(data.id,1)
			end
		end
		role:updateProperty({field = "funcGuide", value = str})
		role:mylog("gm_action", {desc = "sguide", key1 = pms.sender})

	elseif cmd == "RESET" then
		local id = tonum(pms.pm2, 0)
		if id == 0 then
			role:updateProperties({
				newerGuide = "1=1",
				funcGuide = "",
			}, notNotify)
		elseif id == 1 then
			role:updateProperty({field = "newerGuide", value = "1=1"})
		elseif id == 2 then
			role:updateProperty({field = "funcGuide", value = ""})
		end
		role:mylog("gm_action", {desc = "cguide", int1 = id, key1 = pms.sender})

	end

	return "成功"
end

table.insert(helpDes, {"挑战关卡次数", "actbattle"})
function _M.actbattle(role, pms)
	if not role.activity:isOpen("ChallengeLevel") then return end
	local actData = role.activity:getActData("ChallengeLevel")
	actData["ticket"] = 100
	role.activity:updateActData("ChallengeLevel", actData)

	return "成功"
end

table.insert(helpDes, {"清空背包", "clearbag"})
function _M.clearbag(role, pms)
	-- 装备
	role:updateProperty({field="equips", value = {}})
	-- 道具
	local items = role:getProperty("items"):toNumMap()
	for k, v in pairs(items) do
		role:addItem({itemId = k, count = -v, log = {desc = "gm"}})
	end

	-- 铭文
	local uids = {}
	for uid, _ in pairs(role.runeBag) do
		table.insert(uids, uid)
	end
	role:delRunes(uids, {log = {desc = "gm"}})

	-- 火花
	uids = {}
	for uid, _ in pairs(role.sparkBag) do
		table.insert(uids, uid)
	end
	role:delSparks(uids, {log = {desc = "gm"}})

	return "成功"
end

table.insert(helpDes, {"发送跑马灯", "notice"})
function _M.notice(role, pms)
	local msg = pms.pm1
	SendPacket(actionCodes.Sys_commonNotice, MsgPack.pack({body = msg}))

	return "成功"
end

table.insert(helpDes, {"活动关卡", "actbp", "id", "actid"})
function _M.actbp(role, pms)
	local id = tonum(pms.pm1, 0)
	local actid = tonum(pms.pm2, 0)
	if not role.activity:isOpenById(actid, "ChallengeLevel") then return end
	local actData = role.activity:getActData("ChallengeLevel") or {}

	local actCfg = csvdb["activity_battleCsv"][actid]
	if not actCfg then return end
	for k, v in pairs(actCfg) do
		if k <= id then
			local bpInfo = actData[i] or {}
			bpInfo["star"] = 1
			actData[k] = bpInfo
		end
	end
	role.activity:updateActData("ChallengeLevel", actData)

	return "成功"
end

table.insert(helpDes, {"活动拾荒", "actadv", "id", "actid"})
function _M.actadv(role, pms)
	local id = tonum(pms.pm1, 0)
	local actid = tonum(pms.pm2, 0)
	if not role.activity:isOpenById(actid, "AdvLevel") then return end
	local actData = role.activity:getActData("AdvLevel") or {}
	local advInfo = actData[id]
	advInfo["pass"] = 1
	actData[id] = advInfo

	role.activity:updateActData("AdvLevel", actData)

	return "成功"
end

function _M.helpRpc(agent, data)
	SendPacket(actionCodes.Gm_helpRpc, MsgPack.pack({help = helpDes}))
	return true
end

function _M.test(role, pms)
	local id = tonum(pms.pm1, 0)
	local actid = nil
	if id > 100 then
		actid = tonum(pms.pm2, 0)
	end
	--local hero = require ("actions.HeroAction")
	--hero.unlockPoolRpc({role = role}, MsgPack.pack({type = id}))

	--role:sendMail(13, nil, "1=2", {111})
	local file = io.open("draw_hero_"..id..".csv", "a")
	for i=1, 10000 do
		local heroIds = _M.drawHero(role, id, actid)
		for k, v in ipairs(heroIds) do
			print((i - 1)* 10 + k, v)
			file:write(v.."\n")
		end
	end
	io.close(file)
	return "成功"
end

-- 充值回调
function _M.ayncPurchase(role, params)
	return role:handlePurchase(params) or ""
end

-- 获取订单号
function _M.getPurchaseOrder(role, params)
	return role:getPurchaseOrderByPlatform(params) or ""
end


function _M.cz(role, pms)
	local id = tonum(pms.pm1)
	local csvData = csvdb["shop_rechargeCsv"][id]
	if not csvData then
		return "充值id错误, 查看shop_recharge.csv"
	end
	role:recharge({
		id = id,
		transactionId = "GM",
		order = "GM",
		pay_time = skynet.timex(),
	})
	role:mylog("gm_action", {desc = "recharge", int1 = id, key1 = pms.sender})
	return "指令成功"
end

function _M.drawHero(role, t, act)
	local btype = t	-- 1 2 3 4 5	卡池类型  4新手卡池 5心愿卡池
	local subType = 1-- 定向卡池需要传 子类型
	local drawType = 2 -- 1 单抽 2 十连
	if btype ~= 1 then
		subType = 1
	end

	local actid = act
	-- 另开活动卡池
	if actid then
		--if not role.activity:isOpenById(actid, "ActHeroPool") then return end
		local cfg = csvdb["activity_ctrlCsv"][actid]
		if not cfg then return end

		btype = cfg.condition
	end

	local buildTypeData = csvdb["build_typeCsv"][btype]
	if not buildTypeData then return 2 end

	local drawCount = {1, 10} -- 抽取次数
	if not drawCount[drawType] then return 3 end

	local draw_floor_back_counts = globalCsv.draw_floor_back_counts[btype]
	local floorHeroCount = role:getProperty("floorHero")[btype] or 0

	-- 抽取的池子
	local poolMap = buildTypeData["pool"]:toNumMap()
	local poolId = poolMap[subType]
	if not poolId then return 5 end
	
	--TODO 活动覆盖
	local actPoolId = role.activity:getActivityPool(btype, subType)
	if actPoolId ~= 0 then
		poolId = actPoolId
	end

	local unitPool = csvdb["build_unitCsv"][poolId]
	if not unitPool then return 7 end

	-- 开始抽
	local resultPool = {}
	local function fillDrawPool(isFloorBack)
		local condition = {"rare"}
		local values = {}


		for idx, field in ipairs(condition) do
			if not values[idx] then
				local lpool = {}
				local curIdx = 1
				while unitPool[field .. "_" .. curIdx] do
					lpool[curIdx] = {unitPool[field .. "_" .. curIdx]}
					curIdx = curIdx + 1
				end

				if next(lpool) then
					values[idx] =  math.randWeight(lpool, 1)
				end
			end
		end

		local weight = 0
		local up_pool = nil
		local rand_v = math.randomInt(1, 100)
		if values[1] == HeroQuality.SR then
			weight = unitPool["up_sr_weight"]
			up_pool = unitPool["up_sr_id"]
		elseif values[1] == HeroQuality.SSR then
			weight = unitPool["up_ssr_weight"]
			up_pool = unitPool["up_ssr_id"]
			if btype == 5 then
				weight = 3 * weight
			end
		end
		--print(poolId, rand_v, weight, up_pool, values[1])
		if rand_v < weight and up_pool then
			up_pool = up_pool:toArray(true, "=")
			if btype == 5 then -- 爱心卡池，使用玩家设置的备选池子
				up_pool = role:getProperty("wishPool")
				up_pool[1] = 408
				up_pool[2] = 409
				up_pool[3] = 410
			end
			for k, v in ipairs(up_pool) do
				resultPool[v] = {1}
			end
		else
			for itemId, oneData in pairs(isFloorBack and csvdb["build_floorCsv"] or csvdb["build_poolCsv"]) do
				local pool_str = "pool_" .. poolId
				if oneData[pool_str] and oneData[pool_str] ~= "" then
					local itemData = csvdb["itemCsv"][itemId]
					while itemData do
						if itemData.type ~= ItemType.Hero then break end
						local heroData = csvdb["unitCsv"][itemData.id - ItemStartId.Hero]
						if not heroData then break end
						local ok = true
						-- 保底是全随机，不用比较类型
						if not isFloorBack then
							for idx, field in ipairs(condition) do
								if heroData[field] ~= values[idx] then ok = false break end
							end
						end
						if up_pool then
							for k, v in ipairs(up_pool) do
								if v == itemData.id then
									ok = false
									break
								end
							end
						end
						if not ok then break end
						if oneData[pool_str] > 0 then
							resultPool[itemId] = {oneData[pool_str]}  -- itemId, count, 概率
						end
						break
					end
				end
			end
		end
	end

	local guideHero = nil
	if role:getProperty("newerGuide") == "8=1" then
		guideHero = globalCsv.newdraw_hero_item_id or 503
	end

	local ssrCount = 0
	local reward = {}
	local logReward = {}
	local result = {}
	for i = 1, drawCount[drawType] do
		floorHeroCount = floorHeroCount + 1
		local isFloorBack = draw_floor_back_counts and floorHeroCount >= draw_floor_back_counts
		resultPool = {}
		fillDrawPool(isFloorBack)
		if not next(resultPool) then
			skynet.error("random pool error, poolId:" .. poolId, isFloorBack)
			return 8
		end

		local itemId = math.randWeight(resultPool, 1)
		if guideHero then
			itemId = guideHero
		end

		local itemData = csvdb["itemCsv"][itemId]
		if itemData.quality == HeroQuality.SSR then
			ssrCount = ssrCount + 1
			if not guideHero then
				-- 广播获得ssr英雄
				local ntf = {heroId = itemData.id - ItemStartId.Hero, nick = role:getProperty("name")}
				--mcast_util.pub_world(actionCodes.Role_broadGetSSR, MsgPack.pack(ntf))
			end
		end

		if btype == 4 and role:getProperty("newerDraw") == 0 then		-- 新手卡池
			if itemData.quality == HeroQuality.SSR then
				floorHeroCount = 0
			end
		else
			if itemData.quality >= HeroQuality.SR then
				floorHeroCount = 0
			end
		end

		if role:isHaveHero(itemData.id - ItemStartId.Hero) then
			local fragId = itemData.id - ItemStartId.Hero
			local heroData = csvdb["unitCsv"][fragId]
			local count = globalCsv.draw_unit_tofragment[heroData.rare]
			role:award({[fragId] = count}, {log = {desc = "drawHero", int1 = btype, int2 = poolId}})
			logReward[fragId] = (logReward[fragId] or 0) + count
			table.insert(reward, {id = fragId, count = count, from = itemId, fcount = 1})
		else
			role:award({[itemId] = 1}, {log = {desc = "drawHero", int1 = btype, int2 = poolId}})
			logReward[itemId] = (logReward[itemId] or 0) + 1
			table.insert(reward, {id = itemId, count = 1})
		end
	end

	if draw_floor_back_counts then
		local floorHero = role:getProperty("floorHero")
		floorHero[btype] = floorHeroCount
		role:setProperty("floorHero", floorHero)
	end

	if btype == 4 then
		local newCount = role:getProperty("newerDraw")
		role:updateProperty({field="newerDraw", value = newCount + drawCount[drawType]})
	end

	--SendPacket(actionCodes.Hero_drawHeroRpc, MsgPack.pack({reward = reward})) -- 这个 reward 是数组
	for k, v in pairs(reward) do
		local hero = v
		if hero["from"] then
			result[#result+1] = hero["from"]
		else
			result[#result+1] = hero["id"]
		end
	end

	local feedbackId = buildTypeData["can_feedback"] or 0
	if feedbackId ~= 0 then
		-- 达到一定次数，给响应奖励
		local oldVal = role:getProperty("repayHero") or 0
		if actid then
			local actData = role.activity:getActData("ActHeroPool")
			oldVal = actData[btype] or 0
		end
		local newVal = oldVal + drawCount[drawType]
		local drawCardReward, val = role:getDrawCardExtraReward(feedbackId, oldVal, newVal)
		-- 空字符穿代表直接给英雄  走以前repayHeroRpc
		if drawCardReward == "" then
			local repayHeroMaxCount = role:getProperty("repayMaxC") or 0
			repayHeroMaxCount = repayHeroMaxCount + 1

			role:updateProperty({field = "repayMaxC", value = repayHeroMaxCount})
			local even = repayHeroMaxCount % 2
			local id = 0
			if even == 1 then
				id = math.randWeight(csvdb["build_giftCsv"], "pool_"..feedbackId)
			else
				local giftHeroSet = {}
				for gid, cfg in pairs(csvdb["build_giftCsv"]) do
					if cfg["pool_"..feedbackId] ~= 0 and not role:isHaveHero(gid - ItemStartId.Hero) then
						giftHeroSet[gid] = {1}
					end
				end
				if next(giftHeroSet) then
					id = math.randWeight(giftHeroSet, 1)
				end
			end
			if id == 0 then
				id = math.randWeight(csvdb["build_giftCsv"], "pool_"..feedbackId)
			end

			local r,change = {}
			local itemData = csvdb["itemCsv"][id]
			--if itemData.type == ItemType.Hero and role:isHaveHero(itemData.id - ItemStartId.Hero) then
			--	local fragId = itemData.id - ItemStartId.Hero
			--	local heroData = csvdb["unitCsv"][fragId]
			--	local count = globalCsv.draw_unit_tofragment[heroData.rare]
			--	r, change = role:award({[fragId] = count}, {log = {desc = "drawHeroExtraReward"}})
			--	--r = {id = fragId, count = count, from = id, fcount = 1}
			--else
			r, change = role:award({[id] = 1}, {log = {desc = "drawHeroExtraReward"}})
			--end
			SendPacket(actionCodes.Hero_drawHeroExtraRewardNtf, MsgPack.pack(role:packReward(r, change)))
		elseif drawCardReward and drawCardReward ~= "" then
			local r,change = {}
			r, change = role:award(drawCardReward, {log = {desc = "drawHeroExtraReward", int1 = oldVal, int2 = newVal}})
			SendPacket(actionCodes.Hero_drawHeroExtraRewardNtf, MsgPack.pack(role:packReward(r, change)))
		end
		if not actid then
			role:updateProperty({field = "repayHero", value = val})
		else
			local actData = role.activity:getActData("ActHeroPool")
			actData[btype] = val
			role.activity:updateActData("ActHeroPool", actData)
		end
	end
	return result
end


return _M