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 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
  	local hadLeader = false
  	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
  	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 		--编队

  
  	--上一个关卡结束才可以开始新的关卡
  	if next(role:getProperty("advInfo")) then return 8 end
  

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

  	if not chapterData or layer < 1 then return  1 end

  	--是否是中继层

  	if (layer - 1) % globalCsv.adv_can_out_layer_pre ~= 0 then return 3 end

  	local advPass = role:getProperty("advPass")

  	if AdvCommon.isEndless(chapterId) then

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

  		if not role:isFuncOpen(FuncOpenType.AdvEndless) or not role:isFuncOpen(FuncOpenType.AdvRelay) then return 11 end -- 开放了中继模式 和 无尽模式 才可以玩儿无尽模式
  		local maxl = math.floor(role:getProperty("advElM") / 10) * 10
  		local openLayer = {}
  		for i = 0, (globalCsv.adv_endless_open_relay - 1) do
  			local l = maxl - i * globalCsv.adv_can_out_layer_pre
  			if l < 0 then
  				break
  			end
  			openLayer[l] = 1
  		end
  		if not openLayer[layer - 1] then return 10 end

  
  		if layer == 1 then
  			if not role:advChapterIsOpen(chapterId, layer) then return 13 end
  		end

  	else

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

  		if layer > chapterData.limitlevel  then return 4 end
  		-- 关卡开放判断
  		if not role:advChapterIsOpen(chapterId, layer) then return 5 end
  		--中继开放判断
  		if layer ~= 1 and (not role:isFuncOpen(FuncOpenType.AdvRelay) or (advPass[chapterId] or 0) < (layer - 1)) then return 6 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

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

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

  
  	role:getAdvData():initByChapter(chapterId, layer)

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

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

  	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 format = msg.format --编队
  
  	local chapterData = csvdb["adv_chapterCsv"][chapterId]
  	if not chapterData then return end
  
  	local advHang = role:getProperty("advHang")
  	if advHang[chapterId] then return end --正在挂机
  
  	local advPass = role:getProperty("advPass")

  	if AdvCommon.isEndless(chapterId) or advPass[chapterId] ~= chapterData.limitlevel then return end -- 没有全通关

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

  	if not checkFormat(role, format, next(role:getProperty("advInfo"))) then return end --编队是否正确

  
  	local battleV = 0
  	for _, heroId in pairs(format.heros) do
  		local hero = role.heros[heroId]
  		battleV = battleV + hero:getProperty("battleV")
  	end
  	if battleV < chapterData.idleValue then return end -- 战斗力是否满足
  
  	local info = {}
  	info.format = {}
  	info.format.leader = format.leader
  	info.format.heros  = {}
  	for slot, heroId in pairs(format.heros) do
  		info.format.heros[slot] = heroId
  	end
  	info.time = skynet.timex() + chapterData.idleTime --挂机时间
  

  	-- 没有在战斗  用team来挂机了  把team清掉
  	if not next(role:getProperty("advInfo")) then
  		role:updateProperty({field = "advTeam", value = {}})
  	end
  

  	role:changeUpdates({{type = "advHang", field = chapterId, value = info}})
  
  	role.dailyData:updateProperty({field = "advC", delta = 1})

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

  	SendPacket(actionCodes.Adv_startHangRpc, '')
  	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 chapterData = csvdb["adv_chapterCsv"][chapterId]
  	if not chapterData then return end
  	
  	local reward, isFull
  	if skynet.timex() >= info.time then
  		reward = role:award(chapterData.idleReward)
  	else
  		if cancel then
  			if role.dailyData:getProperty("advC") <= 0 then 
  				isFull = true
  			else
  				role.dailyData:updateProperty({field = "advC", delta = -1})
  			end
  		else

  			return
  		end
  	end

  	
  	role:changeUpdates({{type = "advHang", field = chapterId, value = nil}})
  
  	SendPacket(actionCodes.Adv_endHangRpc, MsgPack.pack({reward = reward, 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, math.min(globalCsv.adv_endless_daily_buy_count - role.dailyData:getProperty("advElBC"), role.dailyData:getProperty("advElC"))) then return end
  		cost = {[ItemId.Diamond] = count * globalCsv.adv_endless_daily_buy_cost}
  	else
  		if math.illegalNum(count, 1, math.min(globalCsv.adv_daily_buy_count - role.dailyData:getProperty("advBC"), role.dailyData:getProperty("advC"))) then return end
  		cost = {[ItemId.Diamond] = count * globalCsv.adv_daily_buy_cost}
  	end
  	
  	

  	if not role:checkItemEnough(cost) then return end
  	role:costItems(cost)

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

  	
  	SendPacket(actionCodes.Adv_buyAdvCountRpc, '')

  	return true
  end
  

  function _M.finishTaskRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  
  	local adv = role:getAdvData()
  	local taskId = msg.taskId  -- -1 则是主线任务
  	local status, reward
  	if taskId == -1 then
  		status, reward = 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})

  	SendPacket(actionCodes.Adv_finishTaskRpc, MsgPack.pack({reward = reward}))
  	return true
  end
  

  -- 点击地块（解锁）(触发事件)
  function _M.clickBlockRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  
  	local adv = role:getAdvData()
  	local status = adv:clickBlock(msg.roomId, msg.blockId, msg)
  	if not status then return 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 adv = role:getAdvData()
  	local status = adv:useItem(msg.itemId, msg.count, msg.target) -- target {roomId = 1, blockId = 1} 选择的目标
  	if not status then return end
  	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 dishLevel = role.dinerData:getProperty("dishTree"):getv(msg.potionId, 0)
  	if dishLevel == 0 then
  		return
  	end

  	local adv = role:getAdvData()

  	local status = adv:usePotion(msg.potionId, dishLevel, msg.target) -- target {roomId = 1, blockId = 1} 选择的目标

  	if not status then return end

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

  	return true
  end

  --退出
  function _M.exitAdvRpc(agent, data)
  	local role = agent.role
  	-- local msg = MsgPack.unpack(data)
  	local adv = role:getAdvData()
  	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
  
  	local adv = role:getAdvData()
  	local enemy = adv.battle:getEnemyById(enemyId)
  
  	if 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
  
  	if not player or not player.hp or not player.sp or not enemyId or not key then return end
  	local adv = role:getAdvData()
  	-- 校验
  	if not adv.__battleCache then return end
  	if adv.__battleCache.enemyId ~= enemyId then return end
  	local enemy = adv.battle:getEnemyById(enemyId)
  	if enemy.monsterId ~= monsterId or enemy.roomId ~= roomId or enemy.blockId ~= blockId then return end
  	adv.__battleCache = nil
  
  	
  	local status = adv:clickBlock(roomId, blockId, {player = player})
  	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

  	if not role._advWheelSurfCount then return end
  
  	local drawData = csvdb["adv_wheelsurfCsv"][role:getFuncLv(FuncOpenType.AdvWheelSurf)]
  	if not drawData then return end
  
  	local costs = drawData.cost:toArray(true, "=")
  	local maxt = math.max(#costs, drawData.time)
  
  	if role._advWheelSurfCount >= maxt then 
  		role._advWheelSurfCount = nil 
  		return
  	end
  
  	local cost = costs[role._advWheelSurfCount + 1]
  	if cost > 0 then
  		if not role:checkItemEnough({[ItemId.Diamond] = cost}) then return end
  		role:costItems({[ItemId.Diamond] = cost})
  	end
  
  	role._advWheelSurfCount = role._advWheelSurfCount + 1
  	if role._advWheelSurfCount >= maxt then 
  		role._advWheelSurfCount = nil 
  	end
  
  	local gift = drawData.pool:randWeight(true)
  
  	local reward = role:award({[gift[1]] = gift[2]})
  	SendPacket(actionCodes.Adv_wheelSurfRpc, MsgPack.pack({reward = reward}))
  	return true
  end
  

  function _M.finishAchievRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	-- local ctype = msg.ctype -- 领取类型 1 成就  2 pt累计奖励
  	local chapterId = msg.chapterId --章节id
  	local taskId = msg.taskId  -- 领取id
  
  	local adv = role:getAdvData()
  	
  	local status, reward
  	-- if ctype == 1 then
  	-- 	status = adv:finishAchievement(chapterId, taskId)
  	-- elseif ctype == 2 then
  		status, reward = adv:getAchievementReward(chapterId, taskId)
  	-- end
  	if not status then return end
  	adv:updateAchievement()
  	SendPacket(actionCodes.Adv_finishAchievRpc, MsgPack.pack({reward = reward}))
  	return true
  end
  

  return _M