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 not format then
		format = role:getProperty("advTeam")
	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 actid = msg.actid	--活动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 --正在挂机

	-- 检查活动正确性
	if actid then
		if not role.activity:isOpenById(actid, "AdvLevel") then 
			return 20
		end
		local actCfg = csvdb["activity_adv_chapterCsv"][actid]
		if not actCfg then return 21 end
		actCfg = actCfg[chapterId]
		if not actCfg then return 22 end

		local st = toUnixtime(actCfg["unlockTime"]..string_format("%02x", RESET_TIME))
		if st > skynet.timex() then return 23 end

		if actCfg["prepose"] ~= "" then
			local type, cid = actCfg["prepose"]:toArray(true, "=")
			if type == 1 then
				local actData = role.activity:getActData("ChallengeLevel")
				local battleInfo = actData[cid] or {}
				if (battleInfo["star"] or 0) == 0 then
					return 24
				end
			elseif type == 2 then
				local actData = role.activity:getActData("AdvLevel")
				local advInfo = actData[cid] or {}
				if not advInfo["pass"] then
					return 25
				end
			end
		end
	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) 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,
		actid = actid
	})
	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.duration = 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

local function addHeroFaith(role, heroId, exp)
	local hero = role.heros[heroId]
	if not hero then
		return
	end

	hero:addHeroFaith(exp)
	return hero:getProperty("faith")
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, heroFaithMap
	local heroCnt = 0
	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 exp = info.duration / 60
		heroFaithMap = {}
		for _, heroId in pairs(info.format.heros) do
			local curFaith = addHeroFaith(role, heroId, exp)
			heroFaithMap[heroId] = curFaith
			heroCnt = heroCnt + 1
		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", {})
	role:checkTaskEnter("AdvHangHeroCnt", {count = heroCnt})

	SendPacket(actionCodes.Adv_endHangRpc, MsgPack.pack({reward = reward, change = change, isFull = isFull, heroFaith = heroFaithMap}))
	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
	
	adv:useItem(itemId, count, target)
	
	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, 1)
	if potionLv < 1 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

	if not isCanContinue(role) then return end
	local adv = role:getAdvData()
	if not adv:cost({[potionId] = 1}, {}, true) then return 4 end
	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

	adv:cost({[potionId] = 1}, {log = {desc = "usePotion", int1 = potionId}})
	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)
	if not isCanContinue(role) then return end
	-- 冒险中途退出的时候要把引导步骤设定到成就引导
	if not role:checkOverGuide(57) then
		role:saveGuide(57,1,true)
	end
	local adv = role:getAdvData()
	adv:mylog({desc = "exit"})
	local status = adv:exit() -- target {roomId = 1, blockId = 1} 选择的目标
	SendPacket(actionCodes.Adv_exitAdvRpc, MsgPack.pack({events = adv:popBackEvents()}))
	return true
end 

--开始战斗
function _M.startBattleRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)

	-- 校验一下信息
	local roomId = msg.roomId
	local blockId = msg.blockId
	local monsterId = msg.monsterId
	local enemyId = msg.enemyId
	if not enemyId then return end
	if not isCanContinue(role) then return end

	local adv = role:getAdvData()

	if adv:isWaitChooseArtifact() then return end
	local enemy = adv.battle:getEnemyById(enemyId)

	if not enemy or enemy.monsterId ~= monsterId or enemy.roomId ~= roomId or enemy.blockId ~= blockId or enemy.lock or enemy.isDead then return end

	local key = tostring(math.random())
	adv.__battleCache = {
		enemyId = enemyId,
		key = key
	}
	SendPacket(actionCodes.Adv_startBattleRpc, MsgPack.pack({key = key}))
	return true
end

-- 结束战斗
function _M.endBattleRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)
	local roomId = msg.roomId
	local blockId = msg.blockId
	local monsterId = msg.monsterId
	local enemyId = msg.enemyId
	local key =  msg.key
	local player = msg.player
	local bySkill = msg.bySkill --死于 技能

	if not player or not player.hp or not player.sp or not enemyId or not key then return end
	if not isCanContinue(role) then return end
	
	local adv = role:getAdvData()
	if adv:isWaitChooseArtifact() then return end
	-- 校验
	if not adv.__battleCache then return end
	if adv.__battleCache.enemyId ~= enemyId then return end
	local enemy = adv.battle:getEnemyById(enemyId)
	if not enemy or enemy.monsterId ~= monsterId or enemy.roomId ~= roomId or enemy.blockId ~= blockId then return end
	adv.__battleCache = nil

	-- 打完野猪怪
	role:finishGuide(52)
	-- 调理剂使用引导(生命药剂)
	if not role:checkOverGuide(61) then
		local potionBag = role:getProperty("advItems"):toNumMap()
		local own = potionBag[10] or 0
		if own > 0 then
			-- 造假
			player.hp = player.hp * 0.8
			role:saveGuide(61,1,true)
		end
	end
	adv:mylog({desc = "endBattle"})
	local status = adv:clickBlock(roomId, blockId, {player = player, enemy = msg.enemy, bySkill = bySkill})

	if not status then return end
	SendPacket(actionCodes.Adv_endBattleRpc, MsgPack.pack({events = adv:popBackEvents()}))
	return true
end

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

-- 	local id = msg.id 
-- 	local count = msg.count or 1
-- 	local mergeData = csvdb["adv_mergeCsv"][id]
-- 	if not mergeData then return 1 end

-- 	if not role:isFuncOpen(FuncOpenType.AdvWS) or role:getFuncLv(FuncOpenType.AdvWS) < mergeData.unlock then return 2 end

-- 	local advWs = role.dailyData:getProperty("advWs")
-- 	if math.illegalNum(count, 1, mergeData.limit - (advWs[id] or 0)) then return 3 end

-- 	local cost = mergeData.formula:toNumMap()
-- 	for k, v in pairs(cost) do
-- 		cost[k] = v * count
-- 	end
-- 	if not role:checkItemEnough(cost) then return 4 end

-- 	role:costItems(cost)
-- 	advWs[id] = (advWs[id] or 0) + count
-- 	role.dailyData:updateProperty({field = "advWs", value = advWs})
-- 	local reward = role:award({[id] = count})
-- 	SendPacket(actionCodes.Adv_workshopRpc, MsgPack.pack({reward = reward}))
-- 	return true
-- end

function _M.wheelSurfRpc(agent, data)
	local role = agent.role
	-- if not role:isFuncOpen(FuncOpenType.AdvWheelSurf) then return end -- 默认解锁

	local msg = MsgPack.unpack(data)

	local ptype = msg.ptype  -- 池子类型 1, 2
	local ctype = msg.ctype  -- 抽取次数  1 1次，2 10次

	local countPool = {
		[1] = 1,
		[2] = 10
	}
	local count = countPool[ctype]
	if not count then return 1 end

	if ptype == 2 and not role:isFuncOpen(FuncOpenType.AdvEndless) then
		return 2
	end

	local drawTypeData = csvdb["adv_wheelsurfCsv"][ptype]
	if not drawTypeData then return 3 end
	local drawData = drawTypeData[role:getAdvWheelSurfLv(ptype)]
	if not drawData then return 4 end

	local cost = drawData.cost:toArray(true, "=")
	local costs = {[ItemId.OldCoin] = cost[ctype]}
	if not next(costs) then return 6 end


	if not role:checkItemEnough(costs) then return 5 end
	role:costItems(costs, {log = {desc = "advWheelSurf", int1 = ptype}})
	local oldLv, lv = role:addAdvLvExp(costs[ItemId.OldCoin] or 0)
	local advDrawB = role:getProperty("advDrawB")
	advDrawB[ptype] = (advDrawB[ptype] or 0) + count
	role:updateProperty({field = "advDrawB", value = advDrawB})
	-- 随机池子
	local reward = {}
	local backReward = {}
	for i = 1, count do
		local pool = drawData.weight:randWeight()
		local gift = drawData["pool" .. pool]:randWeight(true)
		reward[gift[1]] = (reward[gift[1]] or 0) + gift[2]
		table.insert(backReward, gift)
	end
	role:award(reward, {log = {desc = "advWheelSurf", int1 = ptype}})
	role:finishGuide(58)

	role:checkTaskEnter("AdvDraw", {count = count, ptype = ptype})
	role:mylog("adv_action", {desc = "advWheelSurf", int1 = ptype, int2 = count})

	role:log("mission_pick_fund", {
		item_id = ItemId.OldCoin, -- 资助花费道具ID
		mission_pick_fund_amount = costs[ItemId.OldCoin], -- 资助花费道具数量
		mission_pick_fund_cnt = count, -- 资助花费道具次数，1或者10
		mission_pick_fund_reward = reward, -- 资助获得奖励，[{"id":100,"num":10},{"id":101,"num":20},{"id":102,"num":30}]
		mission_pick_fund_stagereward = {}, -- 资助阶段奖励
		mission_pick_fund_beflv = oldLv, -- 资助前资助等级
		mission_pick_fund_aftlv = lv, -- 资助后资助等级
	})

	SendPacket(actionCodes.Adv_wheelSurfRpc, MsgPack.pack({reward = backReward}))
	return true
end
function _M.repayWheelSurfRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)

	local ptype = msg.ptype

	if ptype == 2 and not role:isFuncOpen(FuncOpenType.AdvEndless) then
		return
	end

	local drawTypeData = csvdb["adv_wheelsurfCsv"][ptype]
	if not drawTypeData then return end
	local drawData = drawTypeData[role:getAdvWheelSurfLv(ptype)]
	if not drawData then return end

	local advDrawB = role:getProperty("advDrawB")
	if (advDrawB[ptype] or 0) < globalCsv.adv_draw_back_cond then
		return
	end
	advDrawB[ptype] = advDrawB[ptype] - globalCsv.adv_draw_back_cond
	role:updateProperty({field = "advDrawB", value = advDrawB})
	local gift = drawData["pool3"]:randWeight(true)
	local reward, change = {[gift[1]] = gift[2]}
	reward, change = role:award(reward, {log = {desc = "advRepayWheelSurf", int1 = ptype}})
	role:mylog("adv_action", {desc = "advRepayWheelSurf", int1 = ptype})

	SendPacket(actionCodes.Adv_repayWheelSurfRpc, MsgPack.pack(role:packReward(reward, change)))
	return true
end

function _M.finishAchievRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)
	local ctype = msg.ctype or 2 -- 领取类型 1 成就  2 pt累计奖励
	local chapterId = msg.chapterId --章节id
	local taskId = msg.taskId  -- 领取id

	local adv = role:getAdvData()

	local status, reward, change
	if ctype == 1 then
		status, reward, change = adv:finishAchievement(chapterId, taskId)
	elseif ctype == 2 then
		status, reward, change = adv:getAchievementReward(chapterId, taskId)
	end
	if not status then return end
	adv:updateAchievement()
	role:finishGuide(57)
	role:mylog("adv_action", {desc = "finishAchiev", short1 = ctype, int1 = chapterId, int2 = taskId})

	SendPacket(actionCodes.Adv_finishAchievRpc, MsgPack.pack(role:packReward(reward, change)))
	return true
end

function _M.rankRpc(agent, data)
	local role = agent.role

	local list = {}
	local ids = redisproxy:zrevrange(role:getAdvRankKey(), 0 , 99, "WITHSCORES")
	local redret = {}
	if ids and next(ids) then
		redret = redisproxy:pipelining(function (red)
			for i = 1, #ids, 2 do
				local roleId = ids[i]
				local score = tonum(ids[i + 1])
				table.insert(list, {roleId = tonumber(roleId), score = score})
				red:hget(RANK_ADV_INFO, roleId)
			end
		end)
	end
	for i = 1, #redret do
		local player = MsgPack.unpack(redret[i])
		player.format = nil
		list[i].player = player
	end
	local redret = redisproxy:pipelining(function(red)
		red:ZREVRANK(role:getAdvRankKey(), role:getProperty("id"))
		red:zscore(role:getAdvRankKey(), role:getProperty("id"))
	end)
	local rank = redret[1]
	if not rank then
		rank = -1
	else
		rank = redret[1] + 1
	end
	local score = tonum(redret[2], 0)

	SendPacket(actionCodes.Adv_rankRpc, MsgPack.pack({list = list, rank = rank, score = score}))
	return true
end

function _M.refreshSupportRpc(agent, data)
	local role = agent.role

	local cr = role.dailyData:getProperty("advSupRe")	
	local al = role:getAdvSupportFreeCount()

	if cr < al then  --免费
		role.dailyData:updateProperty({field = "advSupRe", delta = 1})
	else -- 付费
		if not role:checkItemEnough({[ItemId.Diamond] = globalCsv.adv_support_refresh_cost}) then return end
		role:costItems({[ItemId.Diamond] = globalCsv.adv_support_refresh_cost}, {log = {desc = "advReSupport"}})
	end

	role:advRandomSupportEffect()
	role:mylog("adv_action", {desc = "advSupRe", short1 = cr < al and 0 or 1})

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

function _M.roleFormatRpc(agent , data)
	local role = agent.role
	local msg = MsgPack.unpack(data)
	local index = msg.index	-- 阵容索引
	local title = msg.title -- 阵容名称
	local team = {}
	for slot, heroId in pairs(msg.heros) do
		if not role.heros[heroId] then
			return 1
		end
	end

	if index > 10 then
		return 2
	end

	team.heros = {}
	for slot, heroId in pairs(msg.heros) do
		team.heros[slot] = heroId
	end
	team.leader = msg.leader
	team.leader2 = msg.leader2
	team.title = title
	role:setAdvTeamFormat(index, team)

	local advTeam = role:getProperty("advTeam")
	local curIndex = advTeam.index
	if curIndex == index then
		table.clear(advTeam)

		advTeam.heros = {}
		for slot, heroId in pairs(msg.heros) do
			advTeam.heros[slot] = heroId
		end
		advTeam.leader = msg.leader
		advTeam.leader2 = msg.leader2
		advTeam.index = index
		role:updateProperty({field = "advTeam", value = advTeam})
	end

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

function _M.selectTeamRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)
	local index = msg.index	-- 阵容索引
	local team = role:getAdvTeamFormat(index)
	if not next(team) then return end
	team["index"] = index
	role:updateProperty({field = "advTeam", value = team})

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

return _M