local Room = require "adv.AdvRoom"
  local Passive = require "adv.AdvPassive"
  local AdvCommon = require "adv.AdvCommon"

  
  local Buff = require "adv.AdvBuff"

  -- 一层地图
  local Map = class("AdvMap")
  -- 内部方法声明
  local createMap, getEventLib
  
  

  function Map:ctor(adv, mapIdx, mapInfo, isEnter, isNewRelay)

  	self.adv = adv

  	local isNew = type(mapInfo) == "number"
  	if isNew then -- mapInfo 传入 id

  		mapInfo = createMap(self, mapInfo, isEnter, isNewRelay)  -- 生成地图

  	end
  	if not mapInfo then return end
  
  	self.mapIdx = mapIdx
  	self.mapId = mapInfo.mapId

  	self.isShow = mapInfo.isShow  -- 是否全部展示 -- 客户端用

  	self.rooms = {}

  	self:loadRooms(mapInfo.rooms, isNew, isNewRelay)

  end
  

  function Map:loadRooms(rooms, isNew, isNewRelay)

  	local mapInfoCsv = csvdb["mapCsv"][self.mapId]
  	local mapData = csvdb["map_" .. mapInfoCsv["path"] .. "Csv"]

  	for roomId, roomName in pairs(mapData["rooms"]) do
  		if roomName == "path" then

  			self.rooms[roomId] = Room.new(self, roomId, mapData["path"], rooms[roomId], true, isNewRelay, mapInfoCsv.type)

  		else
  			roomName = roomName:gsub("/", "_")

  			self.rooms[roomId] = Room.new(self, roomId, csvdb["room_" .. roomName .. "Csv"], rooms[roomId], false, isNewRelay, mapInfoCsv.type)

  		end
  	end 

  
  	if mapInfoCsv.type == 2 and isNew then
  		self:showMap()
  	end

  end
  

  function Map:initBattleAfter()
  	for roomId, room in pairs(self.rooms) do
  		room:initBattleAfter()
  	end
  end
  

  
  function Map:getMapInfoCsv()
  	return csvdb["mapCsv"][self.mapId]
  end
  

  function Map:getDB()
  	local map = {}
  	map.mapId = self.mapId

  	map.isShow = self.isShow

  	map.rooms = {}
  	for roomId, room in pairs(self.rooms) do
  		map.rooms[roomId] = room:getDB()
  	end
  	return map
  end
  

  function Map:showMap()
  	self.isShow = true
  end
  

  function Map:isAllOpen()
  	for roomId, room in pairs(self.rooms) do
  		for blockId, block in pairs(room.blocks) do
  			if not block.isOpen then
  				return false
  			end
  		end
  	end
  	return true
  end
  

  --结束本层的时候调用
  function Map:checkOver()
  	local mapCsv = csvdb["mapCsv"][self.mapId]
  
  	if mapCsv.clearType == 1 then -- 消耗

  		if self.adv:cost(mapCsv.clear:toNumMap(), {log = {desc = "overCost", int1 = self.mapId}}) then return true end

  	elseif mapCsv.clearType == 2 then -- 杀光
  		if #self.adv.battle.player:getTeam(2) == 0 then return true end
  	elseif mapCsv.clearType == 3 then -- 持有
  		if self.adv:cost(mapCsv.clear:toNumMap(), {}, true) then return true end

  	elseif mapCsv.clearType == 4 then

  		return self:isAllOpen()

  	else
  		return true
  	end
  end
  
  --随机一个空的位置生成怪， 如果没有就没有	
  function Map:addNewMonsterRand(monsterId, where)
  	local room, block
  	if where then
  		room, block = where[1], where[2]
  	else
  		local pool = {}
  		for _, room_ in pairs(self.rooms) do
  			for _, block_ in pairs(room_.blocks) do
  				if block_.isOpen and not block_.event then
  					table.insert(pool, {room_, block_})
  				end
  			end
  		end
  		if not next(pool) then return end
  		local idx = math.randomInt(1, #pool)
  		room, block = pool[idx][1], pool[idx][2]
  	end
  	
  	if not monsterId then

  		local eventLib = getEventLib(self, AdvEventType.Monster)

  		if not next(eventLib[AdvEventType.Monster][0]) then return false end
  		monsterId = math.randWeight(eventLib[AdvEventType.Monster][0], "showup")
  	end
  

  	local event = {

  		etype = AdvEventType.Monster,

  		id = monsterId,
  	}

  	block:updateEvent(event)
  

  	return room, block
  end
  

  -- 在指定地块类型上 放置指定类型事件id
  function Map:layEventToStage(eventType, eventId, count, stage)
  	local pool = {}
  	for _, room_ in pairs(self.rooms) do
  		for _, block_ in pairs(room_.blocks) do
  			if block_.isOpen and not block_.event and block_:getStageType() == stage then
  				table.insert(pool, {room_, block_})
  			end
  		end
  	end
  	if not next(pool) then return {} end
  	local change = {}
  	count = math.min(#pool, count) 
  	for i = 1, count do
  		local idx = math.randomInt(1, #pool)
  		local room, block = pool[idx][1], pool[idx][2]
  		table.remove(pool, idx)
  
  		local event = {
  			etype = eventType,
  			id = eventId,
  		}
  		block:updateEvent(event)
  		table.insert(change, {room, block})
  	end
  	return change
  end
  
  -- 地图中指定事件 切换为另一个事件
  function Map:eventChangeToOther(eventTypeF, eventIdF, eventTypeT, eventIdT, count)
  	count = count or 1
  	local pool = {}
  	for _, room_ in pairs(self.rooms) do
  		for _, block_ in pairs(room_.blocks) do
  			if block_.isOpen and block_:getEventType() == eventTypeF and block_.event.id == eventIdF then
  				table.insert(pool, {room_, block_})
  			end
  		end
  	end
  	if not next(pool) then return {} end
  	local change = {}
  	count = math.min(#pool, count) 
  	for i = 1, count do
  		local idx = math.randomInt(1, #pool)
  		local room, block = pool[idx][1], pool[idx][2]
  		table.remove(pool, idx)
  
  		local event = {
  			etype = eventTypeT,
  			id = eventIdT,
  		}
  		block:updateEvent(event)
  		table.insert(change, {room, block})
  	end
  	return change
  end
  

  function Map:clearEventById(eventType, eventId, count, exclude)

  	count = count or 0
  	eventId = eventId or 0

  	exclude = exclude or {}

  
  	local pool = {}

  	for roomId, room_ in pairs(self.rooms) do
  		exclude[roomId] = exclude[roomId] or {}
  		for blockId, block_ in pairs(room_.blocks) do
  			if not exclude[roomId][blockId] and block_.isOpen and block_:getEventType() == eventType and (eventId == 0 or block_.event.id == eventId) then

  				table.insert(pool, {room_, block_})
  			end
  		end
  	end
  	if not next(pool) then return {} end
  	local change = {}
  	if count == 0 then
  		count = #pool
  	else
  		count = math.min(#pool, count) 
  	end
  	for i = 1, count do
  		local idx = math.randomInt(1, #pool)
  		local room, block = pool[idx][1], pool[idx][2]
  		table.remove(pool, idx)
  
  		block:updateEvent(nil)
  		table.insert(change, {room, block})
  	end
  	return change
  end
  

  -- 随机翻开 num 个 以开放的房间的 地块

  function Map:openBlockRand(num, isPlayer, ignoreBack)

  	local pool = {}
  	for _, room in pairs(self.rooms) do
  		if room.isShow and not room.isPath then
  			for _, block in pairs(room.blocks) do
  				if not block.isOpen then
  					table.insert(pool, {room.roomId, block.blockId})
  				end
  			end
  		end
  	end
  	if #pool <= num then
  		for _, temp in ipairs(pool) do

  			self:openBlock(temp[1], temp[2], isPlayer, ignoreBack)

  		end
  	else
  		for i = 1, num do
  			local idx = math.randomInt(1, #pool)

  			self:openBlock(pool[idx][1], pool[idx][2], isPlayer, ignoreBack)

  			table.remove(pool, idx)
  		end
  	end
  end
  
  

  -- 打开一个地块 操作翻开地块的入口方法 ！！！

  function Map:openBlock(roomId, blockId, isPlayer, ignoreBack)

  	local room = self.rooms[roomId]
  	if not room then return end
  	local block = room.blocks[blockId]
  	if not block then return end

  	local status = room:openBlock(block)
  	
  	if status then
  		if isPlayer then
  			self.adv.battle.player:triggerPassive(Passive.OPEN_BLOCK)

  			self.adv.owner:checkTaskEnter("AdvOpenBlock")

  
  			-- 潜行检查
  		 	local sneakBuff = self.adv.battle.player:hadBuff(Buff.SNEAK)
  		 	if sneakBuff then
  		 		local enemys = self:getEnemysBySize(roomId, blockId, 2)
  		 		if #enemys > 0 then
  		 			sneakBuff:uncover()
  		 		end
  		 	end

  		end
  
  		if not ignoreBack then
  			self.adv:backBlockChange(roomId, blockId)
  		end

  	end

  end
  

  function Map:openBlocksBySize(roomId, blockId, size, isPlayer, ignoreBack)

  	local blocks = self:getBlocksBySize(roomId, blockId, size)
  	for _, block in pairs(blocks) do

  		self:openBlock(block.room.roomId, block.blockId, isPlayer, ignoreBack)

  	end
  end
  

  function Map:openBlocksByRoom(roomId, isPlayer, ignoreBack)

  	local room = self.rooms[roomId]

  	if not room then return end 

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

  		self:openBlock(roomId, blockId, isPlayer, ignoreBack)

  	end
  end
  

  function Map:openAllBlocks(isPlayer, ignoreBack)

  	for roomId, room in pairs(self.rooms) do

  		self:openBlocksByRoom(room.roomId, isPlayer, ignoreBack)

  	end
  end
  

  
  --获取，某个位置上的 room 和 block
  function Map:getRBByPos(c, r)
  	for roomId, room in pairs(self.rooms) do
  		local block = room:getBByGPos(c, r)
  		if block then
  			return room, block
  		end
  	end
  end
  
  function Map:getAroundBlocks(room, block)
  	local blocks = {}
  	local range = {1, -1}
  	local col, row = room:tranLtoG(block.col, block.row)
  	for _, add in ipairs(range) do
  		local rroom, rblock = self:getRBByPos(col + add, row)
  		if rroom then
  			table.insert(blocks, {rroom, rblock})
  		end
  	end
  	for _, add in ipairs(range) do
  		local rroom, rblock = self:getRBByPos(col, row + add)
  		if rroom then
  			table.insert(blocks, {rroom, rblock})
  		end
  	end
  	return blocks
  end
  

  function Map:getBlocksBySize(roomId, blockId, size)
  	local blocks = {}
  	local room = self.rooms[roomId]
  	if not room then return end
  	local block = room.blocks[blockId]
  	if not block then return end
  
  	local col, row = room:tranLtoG(block.col, block.row)
  
  	size = math.floor(size  /  2)
  	for c = col - size, col + size do
  		for r = row - size, row + size do
  			local rroom, rblock = self:getRBByPos(c, r)
  			if rroom then
  				table.insert(blocks, rblock)
  			end
  		end
  	end
  	return blocks
  end
  

  function Map:getEnemysBySize(roomId, blockId, size)
  	local blocks = self:getBlocksBySize(roomId, blockId, size)
  	local enemys = {}
  	for _, block in ipairs(blocks) do
  		if block:isMonster() then
  			local e = self.adv.battle:getEnemy(block.room.roomId, block.blockId)
  			if e then
  				table.insert(enemys, e)
  			end
  		end
  	end
  	return enemys
  end
  

  -----------------------------随机地图-----------------------------
  

  -- isEnter isNewRelay 区分中继层的类型   --是否是开始进入  是否是第一次进入
  createMap = function(self, mapId, isEnter, isNewRelay)

  	local mapInfo = {}
  	mapInfo.rooms = {}
  	mapInfo.mapId = mapId
  	local mapCsvData =csvdb["mapCsv"][mapId]
  	local mapData = csvdb["map_" .. mapCsvData["path"] .. "Csv"]
  	if not mapData then 
  		error("mapId " .. mapId .. " dont exist!")
  		return 
  	end

  
  	local etypeToStr = {
  		[AdvEventType.Choose] = "choose",
  		[AdvEventType.Drop] = "drop",
  		[AdvEventType.Monster] = "monster",
  		[AdvEventType.Trader] = "trader", 
  		[AdvEventType.Build] = "building",
  		[AdvEventType.Trap] = "trap",
  		[AdvEventType.Click] = "click",
  	}
  
  	local highLevelEvent = {}
  	for _etype, _str in pairs(etypeToStr) do
  		if mapCsvData[_str] ~= "" then
  			highLevelEvent[_etype] = {}
  		end
  		for _id, _count in pairs(mapCsvData[_str]:toNumMap()) do
  			local _curData = csvdb["event_" .. _str .. "Csv"][_id]
  			if _curData then
  				highLevelEvent[_etype][_curData.BlockEventType] = highLevelEvent[_etype][_curData.BlockEventType] or {}

  				highLevelEvent[_etype][_curData.BlockEventType][_id] = {showup = _curData.showup, limit = _count, dlimit = _curData.limit}

  			end
  		end
  	end
  

  	--事件随机

  	local eventLib = getEventLib(self)  -- 同时记录出现次数

  	local monsterEvents = {}  --处理钥匙掉落
  	local haveBoss = false

  	local haveLChoose = false

  	local eventLimit = self.adv.owner:getProperty("advLimit")

  
  	local function randomEvent(roomId, blockId, eventType)
  		if mapInfo.rooms[roomId]["event"][blockId] then return end --已经有事件了 不覆盖
  		local etype, especial = eventType, 0
  		if eventType > 100 then   -- 特殊事件（固定）
  			etype = math.floor(eventType / 100)
  			especial = eventType % 100
  		end
  		
  		local event = {etype = etype}
  		local randomFunc = {}
  
  		local function randomCommon()

  			-- 刷新地图专属的
  
  			local function randomByLevelLib(lib)
  				-- 刷新通用的
  				if not lib[etype] or not next(lib[etype]) or not lib[etype][especial] then return false end
  				-- 清一下全关卡次数用完的
  				for _eid, _edata in pairs(lib[etype][especial]) do
  					if _edata.dlimit ~= 0 and ((eventLimit[etype] or {})[_eid] or 0) >=  _edata.dlimit then
  						lib[etype][especial][_eid] = nil
  					end
  				end
  
  				if not next(lib[etype][especial]) then return false end
  				event.id = math.randWeight(lib[etype][especial], "showup")
  				if not event.id then return false end
  
  				-- 不是 0 才会记录
  				if lib[etype][especial][event.id].dlimit ~= 0 then
  					eventLimit[etype] = eventLimit[etype] or {}
  					eventLimit[etype][event.id] = (eventLimit[etype][event.id] or 0) + 1
  				end
  
  				-- 消除单层次数用完的
  				if lib[etype][especial][event.id].limit > 1 then
  					lib[etype][especial][event.id].limit = lib[etype][especial][event.id].limit - 1
  				elseif lib[etype][especial][event.id].limit == 1 then
  					lib[etype][especial][event.id] = nil
  				end
  				return true

  			end
  

  			local status = randomByLevelLib(highLevelEvent)
  			if not status then
  				status = randomByLevelLib(eventLib)

  			end

  			return status

  		end
  
  		--入口
  		randomFunc[AdvEventType.In] = function()end
  		--出口

  		randomFunc[AdvEventType.Out] = function()end
  		-- --中继点出口
  		-- randomFunc[AdvEventType.Exit] = function() 
  		-- 	-- if not self.adv.isRelay or self.adv.owner:checkOverGuide(GuideStep.AdvRelay) then return false end
  		-- 	return false
  		-- end

  		--开放出口
  		randomFunc[AdvEventType.InOut] = function() end
  
  		--开放出口
  		randomFunc[AdvEventType.Diner] = function() 

  			-- if not self.adv.isRelay or isEnter or isNewRelay then return false end
  			if not self.adv.isRelay or isEnter then return false end

  		end
  

  		--boss
  		randomFunc[AdvEventType.BOSS] = function()
  			if haveBoss then return false end
  			if randomCommon() == false then
  				return false
  			end
  			haveBoss = true

  			self.haveBoss = true -- 刷新任务用的临时变量

  		end

  		randomFunc[AdvEventType.LinkChoose] = function()
  			if haveLChoose then return false end
  			if self.adv.lchoose.ing then -- 有正在进行的
  				event.id = self.adv.lchoose.ing
  				self.adv.lchoose.ing = nil
  			else
  				if randomCommon() == false then
  					return false
  				end
  			end
  			haveLChoose = true
  		end

  		--怪物
  		randomFunc[AdvEventType.Monster] = function()
  			if randomCommon() == false then
  				return false
  			end
  			table.insert(monsterEvents, event)
  		end
  
  		--选择点
  		randomFunc[AdvEventType.Choose] = randomCommon
  		--掉落点
  		randomFunc[AdvEventType.Drop] = randomCommon
  		--交易所

  		randomFunc[AdvEventType.Trader] = function()

  			-- if self.adv.isRelay and isNewRelay then return false end
  			if self.adv.isRelay then return false end

  			return randomCommon()
  		end

  		--建筑

  		randomFunc[AdvEventType.Build] = function()
  			if self.adv.isRelay and isEnter then return false end
  			return randomCommon()
  		end

  		--陷阱
  		randomFunc[AdvEventType.Trap] = randomCommon
  		--点击生效
  		randomFunc[AdvEventType.Click] = randomCommon
  		--跨层点
  		randomFunc[AdvEventType.Layer] = randomCommon

  
  		if randomFunc[etype] then
  			if randomFunc[etype]() ~= false then
  				if  mapCsvData.clearType == 1 and etype == AdvEventType.BOSS then
  					event.item = mapCsvData.clear:toArray(true, "=") 
  				end
  				mapInfo.rooms[roomId]["event"][blockId] = event
  			end
  		end
  	end
  

  	local function giveEvent(roomId, blockId, eventType, eventId)
  		local event = {etype = eventType, id = eventId}
  		mapInfo.rooms[roomId]["event"][blockId] = event
  	end
  

  
  	local stagePool = {["global"] = {}}
  	for roomId, roomName in pairs(mapData["rooms"]) do
  		stagePool[roomId] = {}
  		mapInfo.rooms[roomId] = {event = {}, open = {}, trap = {}}  -- 事件， open  open == 1 房间内地块全部开放
  		local roomData
  		if roomName == "path" then
  			roomData = mapData["path"]
  		else
  			roomName = roomName:gsub("/", "_")
  			roomData = csvdb["room_" .. roomName .. "Csv"]
  		end
  		for blockId, stageType in pairs(roomData["blocks"]) do
  			if AdvSpecialStage[stageType] then
  				local eventType = AdvEventType[AdvSpecialStage[stageType]] -- 地块固定类型
  				randomEvent(roomId, blockId, eventType)
  			else
  				stagePool["global"][stageType] = stagePool["global"][stageType] or {}
  				stagePool[roomId][stageType] = stagePool[roomId][stageType] or {}
  				table.insert(stagePool["global"][stageType], {room = roomId, block = blockId})
  				stagePool[roomId][stageType][blockId] = 1
  			end
  		end
  	end

  
  	-- 随机功能需要强制随机的东西
  	if self.adv.isRelay and isNewRelay then
  		local relayData = self.adv:isHaveRelay()
  		if relayData then

  
  			-- choose

  			local choose = relayData.choose:toArray(true, "=")
  			local lastCount = stagePool["global"][AdvCodeRandomStage] and #stagePool["global"][AdvCodeRandomStage] or 0

  			for _, chooseId in pairs(choose) do

  				if lastCount <= 0 then break end

  				local idx = math.randomInt(1, lastCount)
  				local cur = stagePool["global"][AdvCodeRandomStage][idx]
  
  				giveEvent(cur["room"], cur["block"], AdvEventType.Choose, chooseId)
  
  				table.remove(stagePool["global"][AdvCodeRandomStage], idx)
  				lastCount = lastCount - 1

  				stagePool[cur["room"]][AdvCodeRandomStage][cur["block"]] = nil

  			end

  
  			-- 掉落
  			local drop = relayData.drop:toNumMap()
  			for dropId, dropCount in pairs(drop) do
  				for i = 1, dropCount do
  					if lastCount <= 0 then break end
  					local idx = math.randomInt(1, lastCount)
  					local cur = stagePool["global"][AdvCodeRandomStage][idx]
  
  					giveEvent(cur["room"], cur["block"], AdvEventType.Drop, dropId)
  
  					table.remove(stagePool["global"][AdvCodeRandomStage], idx)
  					lastCount = lastCount - 1
  					stagePool[cur["room"]][AdvCodeRandomStage][cur["block"]] = nil
  				end
  			end

  		end
  	end
  

  	-- 低保事件
  	local exEvent = {}	
  	-- 首层额外刷新
  	if isEnter then
  		local first = self.adv:supportFirstLayerAddEvent()
  		if first then
  			exEvent = first
  		end
  	end
  	-- 每层额外刷新
  	if not self.adv.isRelay then
  		local every = self.adv:supportEveryLayerAddEvent()
  		if every then
  			for etype, events in pairs(every) do
  				exEvent[etype] = exEvent[etype] or {}
  				for id, num in pairs(events) do
  					exEvent[etype][id] = (exEvent[etype][id] or 0) + num
  				end
  			end
  		end
  	end
  	local lastCount = stagePool["global"][AdvCodeRandomStage] and #stagePool["global"][AdvCodeRandomStage] or 0
  	for etype, events in pairs(exEvent) do
  		if lastCount <= 0 then break end
  		for id, num in pairs(events) do
  			if lastCount <= 0 then break end
  			for i = 1, num do
  				if lastCount <= 0 then break end
  
  				local idx = math.randomInt(1, lastCount)
  				local cur = stagePool["global"][AdvCodeRandomStage][idx]
  
  				giveEvent(cur["room"], cur["block"], etype, id)
  
  				table.remove(stagePool["global"][AdvCodeRandomStage], idx)
  				lastCount = lastCount - 1
  				stagePool[cur["room"]][AdvCodeRandomStage][cur["block"]] = nil
  			end
  		end
  	end
  
  

  	-- 全地图事件 优先级高
  	for stageType, events in pairs(mapData["events"]) do
  		for _, event in ipairs(events) do
  			local lastCount = stagePool["global"][stageType] and #stagePool["global"][stageType] or 0
  			if lastCount <= 0 then break end
  			if math.randomFloat(0, 1) <= (event["rate"] or 1) then
  				local count = math.randomInt(math.min(lastCount, event["minc"]), math.min(lastCount, event["maxc"]))
  				for i = 1, count do
  					local idx = math.randomInt(1, lastCount)
  					local cur = stagePool["global"][stageType][idx]
  					randomEvent(cur["room"], cur["block"], event["event"])
  					table.remove(stagePool["global"][stageType], idx)
  					lastCount = lastCount - 1
  					stagePool[cur["room"]][stageType][cur["block"]] = nil
  				end
  			end
  		end
  	end
  	-- 随机单个房间的事件	
  	for roomId, roomName in pairs(mapData["rooms"]) do
  		local roomData
  		if roomName == "path" then
  			roomData = mapData["path"]
  		else
  			roomName = roomName:gsub("/", "_")
  			roomData = csvdb["room_" .. roomName .. "Csv"]
  		end
  		for stageType, events in pairs(roomData["events"]) do
  			local bpool = {}
  			if stagePool[roomId][stageType] then
  				for block, _ in pairs(stagePool[roomId][stageType]) do
  					table.insert(bpool, block)
  				end
  			end
  			for _, event in ipairs(events) do
  				if #bpool <= 0 then break end
  				if math.randomFloat(0, 1) <= (event["rate"] or 1) then
  					local count = math.randomInt(math.min(#bpool, event["minc"]), math.min(#bpool, event["maxc"]))
  					for i = 1, count do
  						local idx = math.randomInt(1, #bpool)
  						randomEvent(roomId, bpool[idx], event["event"])
  						table.remove(bpool, idx)
  					end
  				end
  			end
  		end
  	end
  
  	if mapCsvData.clearType == 1 and not haveBoss then
  		if not next(monsterEvents) then
  			error("这个地图没有钥匙！！！ mapId : " .. mapId)
  		else
  			local event = monsterEvents[math.randomInt(1, #monsterEvents)]
  			event.item = mapCsvData.clear:toArray(true, "=")  --掉落钥匙
  		end
  	end

  	self.adv.owner:setProperty("advLimit", eventLimit)

  	return mapInfo
  end
  
  --关卡事件库

  getEventLib = function(self, needEventType) -- needEventType  需要的事件
  	local  chapterId, level = self.adv.chapterId, self.adv.level

  	if AdvCommon.isEndless(chapterId) then

  		level = AdvCommon.getEndlessDataLv(chapterId, level)

  	end

  	local libsToType = {
  		["event_monsterCsv"] = {AdvEventType.Monster, AdvEventType.BOSS, AdvEventType.Monster},
  		["event_chooseCsv"] = AdvEventType.Choose,
  		["event_dropCsv"] = AdvEventType.Drop,
  		["event_buildingCsv"] = AdvEventType.Build,
  		["event_traderCsv"] = AdvEventType.Trader,
  		["event_trapCsv"] = AdvEventType.Trap,
  		["event_clickCsv"] = AdvEventType.Click,
  		["event_layerCsv"] = AdvEventType.Layer,

  		["event_linkchooseCsv"] = AdvEventType.LinkChoose,

  	}
  	local eventLib = {}

  
  	local advEventOpenStatus = self.adv.owner:advEventOpenStatus()
  

  	local eventLimit = self.adv.owner:getProperty("advLimit")
  

  	for lib, eventType in pairs(libsToType) do
  		-- init eventLib
  		if type(eventType) == "table" then
  			for _, temp in ipairs(eventType) do
  				eventLib[temp] = {}
  			end
  		else
  			eventLib[eventType] = {}
  		end
  		-- needEventType 只获取这个事件类型
  		if not needEventType or eventLib[needEventType] then 
  			for id, data in pairs(csvdb[lib]) do

  				local etype = type(eventType) == "table" and eventType[data.type] or eventType
  				

  				if data.levelchapter == chapterId and (data.unlockType == 0 or (advEventOpenStatus[etype] or {})[data.unlockType]) then

  					local add = true
  					if etype == AdvEventType.LinkChoose then --link 只有起始任务并且还没完成的进入池子
  						if id % 10 ~= 1 or (data.limit ~= 0 and data.limit <= (self.adv.lchoose[id] or 0)) then
  							add = false
  						end
  					end

  					-- limit 单次上限 默认无限
  					local limit = 0

  					if add and (etype == AdvEventType.LinkChoose or etype == AdvEventType.Choose) then  --只能有一次
  						limit = 1
  					end
  

  					if add then  
  						if AdvCommon.checkIsIn(level, data.leveltype, data.levellimit) then
  							eventLib[etype][data.BlockEventType] = eventLib[etype][data.BlockEventType] or {}

  							eventLib[etype][data.BlockEventType][id] = {showup = data.showup, limit = limit, dlimit = data.limit}

  						end

  					end
  				end
  			end
  			if needEventType then
  				break
  			end
  		end
  	end
  	return eventLib
  end
  

  return Map