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 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 layer == 1 then
			if not role:advChapterIsOpen(chapterId, layer) then return 13 end
		else
			local relayData = role:getAdvData():isHaveRelay(layer, chapterId) 
			if not relayData then return end  -- 不是中继层
			if advElM < relayData.unlockfloor then return 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
		-- 普通模式没有中继 只能从1 开始 中继开放判断
		if 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
	advTeam.leader2 = format.leader2
	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

	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, layer, false, false, layer ~= 1, true, support)
	role:checkTaskEnter("AdvStart", {id = chapterId})
	role:checkTaskEnter("AdvStartSelf", {id = chapterId})
	role:getAdvData():popBackEvents() -- 清一下事件
	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 --正在挂机

	if role:getAdvData():isRunning() and role:getAdvData().chapterId == 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, role:getAdvData():isRunning()) 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.leader2 = format.leader2
	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 role:getAdvData():isRunning() 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.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 chapterData = csvdb["adv_chapterCsv"][chapterId]
	if not chapterData then return end
	
	local reward, isFull
	if skynet.timex() >= info.time then return end  -- 已经完成了

	local cost = math.ceil((info.time - skynet.timex()) / chapterData.idleTime * chapterData.accelerate)

	if not role:checkItemEnough({[ItemId.Diamond] = cost}) then return end
	role:costItems({[ItemId.Diamond] = cost})
	info.time = 0
	role:changeUpdates({{type = "advHang", field = chapterId, value = info}})

	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 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, 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)
	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)

	if not isCanContinue(role) then return end
	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)

	if not isCanContinue(role) then return end
	local adv = role:getAdvData()

	if adv:isWaitChooseArtifact() then return end
	local status, errorCode = adv:clickBlock(msg.roomId, msg.blockId, msg)
	if not status then return 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}, {})
		adv:backUse({[itemId] = count})
	end

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

	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

	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")

	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 end

	local adv = role:getAdvData()
	if not msg.idx then return end
	if not adv:isWaitChooseArtifact() then return end
	local status = adv:chooseArtifact(msg.idx)
	if not status then return 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()

	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 end
	adv:cost(cost, {})
	adv:backCost(cost)
	if status == 1 then -- 现在穿着呢。更新下
		adv:saveDB()
	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

	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
	if not isCanContinue(role) then return end

	local adv = role:getAdvData()

	if adv:isWaitChooseArtifact() then return end
	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
	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 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, 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 costs = drawData.cost:toNumMap()
	for id, count_ in pairs(costs) do
		costs[id] = count_ * count
	end

	if not role:checkItemEnough(costs) then return 5 end
	role:costItems(costs)
	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 pool = drawData.weight:randWeight()
	local reward = {}
	local backReward = {}
	for i = 1, count do
		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)
	role:checkTaskEnter("AdvDraw", {count = count, ptype = ptype})
	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 = {[gift[1]] = gift[2]}
	reward = role:award(reward)

	SendPacket(actionCodes.Adv_repayWheelSurfRpc, 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 or 2 -- 领取类型 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, reward = 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

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

	local list = {}
	local ids = redisproxy:zrevrange(RANK_ADV, 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(RANK_ADV, role:getProperty("id"))
		red:zscore(RANK_ADV, 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})
	end

	role:advRandomSupportEffect()

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

return _M