local Passive = require "adv.AdvPassive"
  

  local AdvCommon = require "adv.AdvCommon"
  local AdvMap = require "adv.AdvMap"

  local Buff = require "adv.AdvBuff"

  local Adv = class("Adv")

  local AdvTask = import(".AdvTask")  --任务相关数据搞出去
  AdvTask.bind(Adv)
  

  function Adv:ctor(owner)
  	assert(owner, "Adv instance must have owner(role)")
  	self.owner = owner
  	self.maps = {}
  	self.battle = nil
  	self.backEvents = {} --发给客户端的事件组

  
  	self.advTask = self.owner:getProperty("advTask")
  	self.advMTask = self.owner:getProperty("advMTask")
  	self.advTaskChange = false -- 任务改变才更新
  

  	self:initByInfo(self.owner:getProperty("advInfo"))

  end
  

  --初始化adv 信息
  function Adv:initByInfo(advInfo)
  	if not next(advInfo) then return end --还没有 开始新地图
  
  	self.chapterId = advInfo.chapterId
  	self.level = advInfo.level or 1

  	self.round = advInfo.round or 0

  	self.score = advInfo.score or {}
  	self.lastEnemyId = advInfo.lastEId or 1
  	self.mapStack = advInfo.mstack or {}

  	self.lchoose = advInfo.lch or {}

  	self.waitArtifact = advInfo.waitAF

  	self.cacheUnlock = advInfo.cacheUnlock or {}

  	self.maps = {}
  	for id, map in ipairs(advInfo.maps or {}) do
  		self.maps[id] = AdvMap.new(self, id, map)

  	end

  
  	self:initBattle()

  end
  

  -- 随机新的地图
  function Adv:initByChapter(chapterId, level, isToNext, notNotify)

  	if not self.chapterId then -- 开始新的章节
  		self.chapterId = chapterId
  		self:checkAchievement(Adv.AchievType.StartBattle, 1)
  	elseif chapterId ~= self.chapterId then  -- 正常不会出现
  		return 
  	end
  	

  	self.level = level or 1

  	self.round = 0

  	self.score = self.score or {}
  	self.lastEnemyId = 1
  	self.mapStack = {1} -- 最后一个为当前的地图

  	self.lchoose = self.lchoose or {}

  	self.cacheUnlock = self.cacheUnlock or {}

  	-- 随机出地图
  	local mapId = self:randomMapId(chapterId, level)
  	self.maps = {}
  	self.maps[1] = AdvMap.new(self, 1, mapId)

  	self:initBattle()
  

  	self:initLayerTask()
  
  	self:checkTask(Adv.TaskType.Arrive)

  	self:checkAdvUnlock(1, self.level)

  	if isToNext then
  		self.battle.player:afterLayer() -- 玩家的buff 清理一下
  		self:scoreChange(AdvScoreType.Level) --增加层级加分
  	end

  	if not notNotify then
  		self:saveDB(notNotify)

  	end

  end

  function Adv:clear()
  	self.chapterId = nil
  	self.level = nil
  	self.score = {}

  	self.round = 0

  	self.lastEnemyId = 1
  	self.mapStack = {}

  	self.lchoose = {}

  	self.maps = {}
  	self.battle = nil

  	self.waitArtifact = nil

  	self.cacheUnlock = {}

  end

  function Adv:saveDB(notNotify)
  	local advInfo,  advTeam = {}, self.owner:getProperty("advTeam")
  	if self.chapterId then

  		advInfo.chapterId = self.chapterId
  		advInfo.level = self.level

  		advInfo.round = self.round

  		advInfo.score = self.score
  		advInfo.lastEId = self.lastEnemyId
  		advInfo.mstack = self.mapStack

  		advInfo.lch = self.lchoose

  		advInfo.waitAF = self.waitArtifact

  		advInfo.cacheUnlock = self.cacheUnlock

  		advInfo.maps = {}

  		self.battle:saveDB()

  		for id , map in ipairs(self.maps) do
  			advInfo.maps[id] = map:getDB()

  		end

  		advTeam.player = self.battle.player:getDB()

  	else
  		advTeam.player = nil

  	end

  
  	self:updateTask(notNotify)

  	self:updateAchievement(notNotify)

  	self.owner:updateProperties({advInfo = advInfo, advTeam = advTeam}, notNotify)

  end
  

  -- 1=抵达x层；2=通关x层；3=完成指定事件；4=完成指定连锁事件
  function Adv:checkAdvUnlock(utype, value)
  	if not self.chapterId then return end
  	local chapter = self.chapterId % 100
  	local reward = {}
  	for id, data in pairs(csvdb["adv_unlockCsv"]) do
  		if data.chapterid == chapter and data.type == utype and value == data.value then
  			--0=立即获得；1=结算时获得
  			if data.time == 0 then
  				reward[data.itemid] = 1
  			elseif data.time == 1 then
  				table.insert(self.cacheUnlock, data.itemid)
  			end
  		end
  	end
  	if next(reward) then
  		self.owner:award(reward)
  	end
  end
  
  function Adv:clearAdvUnlockCache()
  	local reward = {}
  	for _, itemId in ipairs(self.cacheUnlock) do
  		reward[itemId] = 1
  	end
  	if next(reward) then
  		self.owner:award(reward)
  	end
  	self.cacheUnlock = {}
  end
  

  function Adv:initBattle()
  	self.battle = require("adv.AdvBattle").new(self)
  	for _, passiveC in ipairs(self.cachePassiveEvent or {}) do
  		self.battle:triggerPassive(passiveC[1], passiveC[2])

  	end

  	self.cachePassiveEvent = {}

  end
  

  function Adv:triggerPassive(condType, params)
  	self.cachePassiveEvent = self.cachePassiveEvent or {}
  	if not self.battle then
  		table.insert(self.cachePassiveEvent, {condType, params})
  	else
  		self.battle:triggerPassive(condType, params)
  	end

  end
  

  function Adv:getCurMap()
  	return self.maps[self.mapStack[#self.mapStack]]

  end
  

  function Adv:getCurMapIdx()
  	return self.mapStack[#self.mapStack]

  end
  

  function Adv:getRoom(roomId, mapIdx)
  	mapIdx = mapIdx or self:getCurMapIdx()
  	local map = self.maps[mapIdx]
  	if map then
  		return map.rooms[roomId]

  	end

  end
  

  function Adv:getBlock(roomId, blockId, mapIdx)
  	local room = self:getRoom(roomId, mapIdx)
  	if room then
  		return room.blocks[blockId]

  	end

  end
  

  function Adv:isHaveArtifact(id)
  	return self.owner:getProperty("advAFGet")[id]
  end
  
  function Adv:awardArtifact(id, params)
  	if self:isHaveArtifact(id) then return end
  	self.owner:changeUpdates({{type = "advAFGet", field = id, value = 1}}, params.notNotify)

  	self:pushBackEvent(AdvBackEventType.Artifact, {id = id})

  end
  
  
  function Adv:delArtifactEffect(effect)
  	for _, eff in ipairs(effect:toArray()) do
  		local etype, id = table.unpack(eff:toArray(true, "="))
  		if etype == 1 then
  			self.battle.player:addPassive({id = id})
  		elseif etype == 2 then
  			self.battle.player:addBuff(id)
  		end
  	end
  end
  
  function Adv:addArtifactEffect(effect)
  	for _, eff in ipairs(effect:toArray()) do
  		local etype, id = table.unpack(eff:toArray(true, "="))
  		if etype == 1 then
  			self.battle.player:delPassiveById(id)
  		elseif etype == 2 then
  			self.battle.player:delBuffById(id)
  		end
  	end
  end
  
  function Adv:wearArtifact(slot, id)
  	local advAFGet = self.owner:getProperty("advAFGet")
  	local advAFWear = self.owner:getProperty("advAFWear")
  
  	local curWear = {}
  	for _, _id in pairs(advAFWear) do
  		curWear[_id] = 1
  	end
  	if curWear[id] then return end
  
  	if advAFWear[slot] then
  		local oldData = csvdb["adv_artifactCsv"][advAFWear[slot]][advAFGet[advAFWear[slot]]]
  		self:delArtifactEffect(oldData.effect)
  		if oldData.comboId ~= 0 then
  			local comboData = csvdb["adv_artifact_comboCsv"][oldData.comboId]
  			if comboData then
  				local isHaveCombo = true
  				for _, _id in ipairs(comboData.artifactid:toArray(true)) do
  					if not curWear[_id] then
  						isHaveCombo = false
  						break
  					end
  				end
  				if isHaveCombo then
  					self:delArtifactEffect(comboData.effect)
  				end
  			end
  		end
  		curWear[advAFWear[slot]] = nil
  	end
  	
  	curWear[id] = 1
  	local newData = csvdb["adv_artifactCsv"][id][advAFGet[id]]
  	self:addArtifactEffect(newData.effect)
  	if newData.comboId ~= 0 then
  		local comboData = csvdb["adv_artifact_comboCsv"][newData.comboId]
  		if comboData then
  			local isHaveCombo = true
  			for _, _id in ipairs(comboData.artifactid:toArray(true)) do
  				if not curWear[_id] then
  					isHaveCombo = false
  					break
  				end
  			end
  			if isHaveCombo then
  				self:addArtifactEffect(comboData.effect)
  			end
  		end
  	end

  	self.owner:changeUpdates({{type = "advAFWear", field = slot, value = id}})
  	return true
  end
  
  function Adv:artifactLevelUp(id)
  	local advAFGet = self.owner:getProperty("advAFGet")
  	local advAFWear = self.owner:getProperty("advAFWear")
  	local status = 0
  	if advAFWear[id] then -- 穿着呢
  		local oldData = csvdb["adv_artifactCsv"][id][advAFGet[id]]
  		local newData = csvdb["adv_artifactCsv"][id][advAFGet[id] + 1]
  		self:delArtifactEffect(oldData.effect)
  		self:addArtifactEffect(newData.effect)
  		status = 1
  	end
  	self.owner:changeUpdates({{type = "advAFGet", field = id, value = advAFGet[id] + 1}})
  	return status
  end
  
  function Adv:waitChooseArtifact()
  	local chooses = {}
  	local pool = {}
  	local count = 3  --需要多少个
  
  	for id, temp in pairs(csvdb["adv_artifactCsv"]) do
  		if not self:isHaveArtifact(id) and self.owner:isArtifactOpen(id, self:isEndless()) then
  			table.insert(pool, id)
  		end
  	end

  	if #pool == 0 then
  		self:award({[ItemId.AdvPoint] = 48})
  	else
  		for i = 1, math.min(count, #pool) do

  			local idx = math.randomInt(1, #pool)
  			table.insert(chooses, pool[idx])
  			table.remove(pool, idx)
  		end

  		self.waitArtifact = chooses
  		self:backChooseArtifact()

  	end

  end
  
  function Adv:isWaitChooseArtifact()
  	return self.waitArtifact
  end
  
  function Adv:chooseArtifact(index)
  	if not self.waitArtifact or not self.waitArtifact[index] then return end

  	self:award({[self.waitArtifact[index]] = 1})
  	self.waitArtifact = nil

  	return true
  end
  
  function Adv:isEndless()
  	return AdvCommon.isEndless(self.chapterId)
  end

  function Adv:getCurFloorData()
  	if not self.chapterId then return end
  	local chapter = self.chapterId % 100
  	return (csvdb["adv_chapter_floorCsv"][chapter] or {})[self.level]
  end
  

  --关卡通关，非层 score < 0 失败

  function Adv:over(success, isAllPass)

  	local score = self:getScore()

  	local scoreInfo = self.score

  	local reward

  	self.battle.player:triggerPassive(Passive.ADV_OVER, {score = score, level = self.level})

  	if success then

  		reward = self.owner:award(self.owner:getProperty("advItems"):toNumMap())

  		self.owner:checkTaskEnter("AdvPass", {id = self.chapterId, level = self.level, score = score})
  		if isAllPass then
  			self.owner:checkTaskEnter("AdvAllPass", {id = self.chapterId})
  		end

  	end

  	self:clearAdvUnlockCache()

  	self:clear()

  	self.owner:checkTaskEnter("AdvScore", {score = score})

  	self.owner:updateProperty({field = "advItems", value = ""})

  	self.owner:updateProperty({field = "advAFGet", value = {}})

  	self.owner:updateProperty({field = "advAFWear", value = {}})

  	self:backEnd(success, score, scoreInfo, reward)

  end
  

  function Adv:exit()

  	self:over(false)

  	self:saveDB()
  end
  

  function Adv:randomMapId(chapterId, level)
  	local chapterData = csvdb["adv_chapterCsv"][chapterId]
  	if not chapterData then 
  		error("chapterId " .. chapterId .. " dont exist!")
  		return 

  	end

  	if AdvCommon.isEndless(chapterId) then

  		level = AdvCommon.getEndlessDataLv(chapterId, level)

  	else
  		if level > chapterData.limitlevel then 
  			error("level overflow!")
  			return 
  		end

  	end

  	--随出地图Id
  	local raw_pool = chapterData.mapid:toArray(true, "=")

  	local lastMapIds = {}
  	for id, map in ipairs(self.maps or {}) do
  		lastMapIds[map.mapId] = 1

  	end

  	local pool = {}

  	for _, mapId in ipairs(raw_pool) do
  		local temp = csvdb["mapCsv"][mapId]
  		if temp and not lastMapIds[mapId] then
  			if AdvCommon.checkIsIn(level, temp.leveltype, temp.levellimit) then
  				table.insert(pool, mapId)

  			end
  		end
  	end

  	if not next(pool) then 
  		error("mapIds is empty!")
  		return 

  	end

  	return pool[math.randomInt(1, #pool)]

  end
  

  -- 在冒险中获得的物品都发放在冒险背包内
  function Adv:award(gift, params)

  	params = params or {}

  	local tgift = {}
  	if type(gift) == "string" then
  		for _, one in pairs(gift:toTableArray(true)) do
  			tgift[one[1]] = (tgift[one[1]] or 0) + one[2]
  		end
  	else
  		tgift = gift
  	end
  	local items = self.owner:getProperty("advItems")

  	local oldItems = items

  	for itemId, count in pairs(tgift) do

  		if count > 0 then

  			local buffAdd = self.battle.player:getRewardChange(itemId)

  			count = math.floor(math.max(0, (count + buffAdd[0]) * (1 + buffAdd[1]))) --附加 buff 的影响

  			self:scoreChange(AdvScoreType.Item, {itemId, count})

  			self:checkTask(Adv.TaskType.Item, count, itemId)

  			self:checkAchievement(Adv.AchievType.GetItem, count, itemId)

  		end

  		tgift[itemId] = count

  		local origin = items:getv(itemId, 0)
  		local nums = origin + count

  		if csvdb["adv_artifactCsv"][itemId] then -- 获得神器
  			self:awardArtifact(itemId, params)
  		else
  			if nums <= 0 then
  				items = items:delk(itemId)
  				nums = 0
  			else
  				items = items:setv(itemId, nums)

  			end
  		end
  	end

  	if items ~= oldItems then
  		self.owner:updateProperty({field = "advItems", value = items, notNotify = params.notNotify})
  	end
  	return tgift

  end
  
  

  -- 消耗物品 优先冒险背包  --check 只是检查够不够
  function Adv:cost(item, params, check)
  	local items = self.owner:getProperty("advItems")
  	local less = {}
  	local advCost = {}
  	for itemId, count in pairs(item) do
  		advCost[itemId] = - math.min(items:getv(itemId, 0), count)
  		if advCost[itemId] == 0 then
  			advCost[itemId] = nil
  		end
  
  		local last = items:getv(itemId, 0) - count
  		if last < 0 then
  			less[itemId] = -last
  		end
  
  	end
  	if next(less) and not self.owner:checkItemEnough(less) then return end --不够
  	if check then return true end
  	self:award(advCost, params)

  	if next(less) then
  		self.owner:costItems(less, params)
  	end

  	return true
  end
  
  --事件点击处理
  local function clickOut(self, room, block, params)

  	if self:getCurMap():checkOver() then --检查是否可以出去了
  		if #self.mapStack > 1 then -- 处于夹层中
  			table.remove(self.mapStack) --退出夹层

  			self:backLayer(-1)

  		else --处于底层

  
  			local advPass = self.owner:getProperty("advPass")

  			if self:isEndless() then

  				-- 刷新最高层
  				if self.owner:getProperty("advElM") < self.level then
  					self.owner:updateProperty({field = "advElM", value = self.level})
  				end
  			else
  				if self.level > (advPass[self.chapterId] or 0) then
  					self.owner:changeUpdates({{type = "advPass", field = self.chapterId, value = self.level}})
  				end

  			end
  			if params.relay then

  				if self.level % globalCsv.adv_can_out_layer_pre ~= 0  or not self.owner:isFuncOpen(FuncOpenType.AdvRelay) then return end

  			end

  			
  			self:checkAchievement(Adv.AchievType.OverWin, 1, self.level)

  			self:checkAdvUnlock(2, self.level)

  			local levellimit = csvdb["adv_chapterCsv"][self.chapterId].limitlevel

  			if params.relay or (not self:isEndless() and (self.level >= levellimit or not self.owner:advChapterIsOpen(self.chapterId, self.level + 1))) then --关卡结束
  				self:over(true, not self:isEndless() and self.level >= levellimit)

  			else

  				self.battle.player:triggerPassive(Passive.DOWN_LAYER)

  				local curFloorData = self:getCurFloorData()
  				if curFloorData then
  					self:backReward(self:award({[ItemId.AdvPoint] = curFloorData.exp}))
  				end

  				self:initByChapter(self.chapterId, self.level + 1, true, true)
  				self:backNext() --下一关
  			end

  		end

  		return true
  	end
  end
  
  --战斗 普通攻击
  local function clickMonster(self, room, block, params)

  	self.battle:battleBegin(room.roomId, block.blockId, params)

  	return true
  end
  

  local function chooseCommon(self, room, block, chooseData, choose, tag)

  	if not chooseData or not chooseData["button".. choose .."cond"] then return end
  
  	local cond = chooseData["button".. choose .."cond"]:toArray(true, "=")
  	local checkCond = {

  		-- 没有条件
  		[0] = function()
  			return true
  		end,

  		-- 拥有道具
  		[1] = function()
  			if self:cost({[cond[2]] = cond[3]}, {}, true) then
  				return true
  			end
  		end,
  		-- xx角色（todo 队长）
  		[2] = function()

  			local hero = self.owner.heros[self.owner:getProperty("advTeam").leader]
  			if hero and hero:getProperty("type") == cond[2] then
  				return true

  			end
  		end,
  		--消灭所有怪
  		[3] = function()

  			for _, room in pairs(self:getCurMap().rooms) do

  				for _, block in pairs(room.blocks) do

  					if block:isMonster() then

  						return
  					end
  				end
  			end
  			return true
  		end,

  		--制定属性 

  		[4] = function()

  			if (self.battle.player[AttsEnumEx[cond[2]]] or 0) >= cond[3] then

  				return true
  			end
  		end,

  		-- 提交一个物品
  		[5] = function ()
  			if self:cost({[cond[2]] = cond[3]}, {}) then

  				self:backCost({[cond[2]] = cond[3]})

  				return true
  			end
  		end,

  		-- sp 到达指定值
  		[6] = function()
  			if self.battle.player.sp >= cond[2] then
  				return true
  			end
  		end,

  		[7] = function()
  			local buff = self.battle.player:getBuffById(cond[2])
  			if buff and buff:getLayer() >= cond[3] then
  				return true
  			end
  		end,
  		[8] = function()
  			return self:isHaveArtifact(cond[2])
  		end
   	}
  	assert(not cond[1] or checkCond[cond[1]], "error cond, event_" .. (tag or "choose") .. "Csv id :" .. block.event.id)

  	if cond[1] and not checkCond[cond[1]]() then return end

  	local clearBlock = chooseData.keep ~= 1

  	local effects = chooseData["button".. choose .."effect"]:toTableArray(true)
  	for _, effect in ipairs(effects) do

  		local doEffect = {
  			[1] = function() -- 获得某道具N个

  				local count = effect[3] or 1
  				local reward = {}
  				for i = 1, count do
  					local item = csvdb["event_dropCsv"][effect[2]]["range"]:randWeight(true)
  					reward[item[1]] = (reward[item[1]] or 0) + item[2]
  				end
  				self:backReward(self:award(reward, {}))

  			end,
  			[2] = function() --获得冒险buff

  				local layer = effect[3] or 1
  				for i = 1, layer do
  					self.battle.player:addBuff(effect[2])
  				end

  			end,
  			[3] = function() --发现怪物

  				self:getCurMap():addNewMonsterRand(effect[2], {room, block})

  				clearBlock = false
  			end,
  			[4] = function() --无事发生

  			end,

  			[5] = function() --5=属性枚举=数值;直接增加玩家属性
  				local attr
  				if effect[3] == 0 then
  					attr = "sp"
  				else
  					attr = AttsEnumEx[effect[3]]
  					if not AdvAttsEnum[attr] then return end
  				end
  				self.battle.player:addBaseAttr(attr, effect[4], effect[2])
  			end,
  			[6] = function() -- 商店
  				block:updateEvent({
  					etype = AdvEventType.Trader,
  					id = effect[2]
  				})
  				block:randomEvent()
  				clearBlock = false
  			end,
  			[7] = function() -- 建筑
  				block:updateEvent({
  					etype = AdvEventType.Build,
  					id = effect[2]
  				})
  				block:randomEvent()
  				clearBlock = false
  			end,
  			[8] = function() -- 选择
  				block:updateEvent({
  					etype = AdvEventType.Choose,
  					id = effect[2]
  				})
  				block:randomEvent()
  				clearBlock = false
  			end,
  			[9] = function() -- click
  				block:updateEvent({
  					etype = AdvEventType.Click,
  					id = effect[2]
  				})
  				block:randomEvent()
  				clearBlock = false
  			end,
  			[10] = function() -- 陷阱
  				block:updateEvent({
  					etype = AdvEventType.Trap,
  					id = effect[2]
  				})
  				block:randomEvent()
  				clearBlock = false
  			end,

  			[11] = function()  -- 获得神器
  				self:waitChooseArtifact() --等待获取神器

  			end
  		}

  		assert(doEffect[effect[1]], "error effect, event_" .. (tag or "choose") .. "Csv id :" .. block.event.id)

  		doEffect[effect[1]]()
  	end

  	return true, clearBlock
  end
  
  local function clickChoose(self, room, block, params)
  	local choose = params.choose
  	local chooseData = csvdb["event_chooseCsv"][block.event.id]

  	local status, clearBlock = chooseCommon(self, room, block, chooseData, choose, "choose")

  	if not status then return end

  	self:checkAdvUnlock(3, block.event.id)
  	self:checkTask(Adv.TaskType.Choose, 1, block.event.id)
  	self:checkAchievement(Adv.AchievType.Choose, 1, block.event.id)

  	if clearBlock then
  		block:clear()
  	end
  	return true
  end
  
  local function clickLinkChoose(self, room, block, params)
  	local choose = params.choose
  	local chooseData = csvdb["event_linkchooseCsv"][block.event.id]

  	local status, clearBlock = chooseCommon(self, room, block, chooseData, choose, "link")

  	if not status then return end
  
  	-- 完成统计次数
  	local idx = block.event.id % 10
  	if idx == 9 or not csvdb["event_linkchooseCsv"][block.event.id + 1] then --全部完成
  		local startId = math.floor(block.event.id / 10) * 10 + 1
  		self.lchoose[startId] = (self.lchoose[startId] or 0) + 1

  		self:checkAchievement(Adv.AchievType.LinkChoose, 1, startId)

  		self:checkAdvUnlock(4, startId)

  		self.lchoose.cur = self.lchoose.cur or {}
  		table.insert(self.lchoose.cur, {block.event.id, choose})
  		self:pushBackEvent(AdvBackEventType.LinkChooseOver, self.lchoose.cur)
  		self.lchoose.cur = nil