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"
	self.mapIdx = mapIdx
	if isNew then -- mapInfo 传入 id
		mapInfo = createMap(self, mapInfo, isEnter, isNewRelay)  -- 生成地图
	end
	if not mapInfo then return end

	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:randEmptyBlock()
	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)
	return pool[idx][1], pool[idx][2]
end

--随机一个空的位置生成怪， 如果没有就没有	
function Map:addNewMonsterRand(monsterId, where)
	local room, block
	if where then
		room, block = where[1], where[2]
	else
		room, block = self:randEmptyBlock()
		if not room then return end
	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:triggerPassive(Passive.OPEN_BLOCK, {roomId = roomId, blockId = blockId})
			self.adv.owner:checkTaskEnter("AdvOpenBlock")
			self.adv.battle.player:changeSp(1) -- 翻开格子 sp 加1
			-- 潜行检查
		 	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
		
		if self.adv.isRelay and self:isAllOpen() then  -- 发放翻开的奖励
			self.adv:passAdvRelay()
		end
	end
	return status
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:openBlocksIsMonsterByRoom(roomId, count, isPlayer, ignoreBack)
	local room = self.rooms[roomId]
	if not room then return end 

	local allBlock = {}
	for blockId, block in pairs(room.blocks) do
		if block:isMonster() and not block.isOpen then
			table.insert(allBlock, blockId)
		end
	end

	local enemys = {}
	local openBlock = function(blockId)
		if self:openBlock(roomId, blockId, isPlayer, ignoreBack) then
			local e = self.adv.battle:getEnemy(roomId, blockId)
			if e then
				table.insert(enemys, e)
			end
		end
	end

	if not count or count == -1 or count >= #allBlock then
		for _, blockId in ipairs(allBlock)  do
			openBlock(blockId)
		end
	else
		for i = 1, count do
			local idx = math.randomInt(1, #allBlock)
			openBlock(allBlock[idx])
			table.remove(allBlock, idx)
		end
	end
	return enemys
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:getDistance(froomId, fblockId, troomId, tblockId)
	local distance = -1
	local room1 = self.rooms[froomId]
	local room2 = self.rooms[troomId]
	if room1 and room2 then
		local block1 = room1.blocks[fblockId]
		local block2 = room2.blocks[tblockId]
		if block1 and block2 then
			local c1, r1 = room1:tranLtoG(block1.col, block1.row)
			local c2, r2 = room2:tranLtoG(block2.col, block2.row)
			distance = math.max(math.abs(c1 - c2), math.abs(r1 - r2))
		end
	end
	return distance
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:getAroundBlocksPlus(room, block)
	local blocks = {}
	local range = {1, 0, -1}
	local col, row = room:tranLtoG(block.col, block.row)
	for _, c in ipairs(range) do
		for _, r in ipairs(range) do
			if c == 0 and r == 0 then
			else
				local rroom, rblock = self:getRBByPos(col + c, row + r)
				if rroom then
					table.insert(blocks, {rroom, rblock})
				end
			end
		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

-- 找周围的空格子 最多 49 个
function Map:getEmptyBlocks(roomId, blockId, count)
	local blocks = {}
	if count == 0 then return blocks end
	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)

	-- 找周围49个格子
	for range = 0, 3 do
		if range == 0 then
			if block.isOpen and not block:getEventType() then
				blocks[#blocks + 1] = block
				if #blocks >= count then
					return blocks
				end
			end
		else
			for _, c in ipairs({col - range , col + range}) do
				for r = row - range, row + range do
					local rroom, rblock = self:getRBByPos(c, r)
					if rroom and rblock.isOpen and not rblock:getEventType() then
						blocks[#blocks + 1] = rblock
						if #blocks >= count then
							return blocks
						end
					end
				end
			end

			for _, r in ipairs({row - range , row + range}) do
				for c = col - range + 1, col + range - 1 do
					local rroom, rblock = self:getRBByPos(c, r)
					if rroom and rblock.isOpen and not rblock:getEventType() then
						blocks[#blocks + 1] = rblock
						if #blocks >= count then
							return blocks
						end
					end
				end
			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

function Map:getEventTypeAllMap(eventType)
	local blocks = {}
	if not eventType then return blocks end
	for roomId, room in pairs(self.rooms) do
		for blockId, block in pairs(room.blocks) do
			if block.isOpen and block:getEventType() == eventType then
				table.insert(blocks, block)
			end
		end
	end
	return blocks
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
			local curData = csvdb["event_monsterCsv"][event.id]
			if curData.noKey and curData.noKey == 1 then
			else
				table.insert(monsterEvents, event)
			end
		end

		--选择点
		randomFunc[AdvEventType.Choose] = randomCommon
		--掉落点
		randomFunc[AdvEventType.Drop] = randomCommon
		--交易所
		randomFunc[AdvEventType.Trader] = function()
			-- if self.adv.isRelay and isNewRelay 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 self.mapIdx == 1 and not self.adv.isRelay and self.adv.chapterId ~= 100 then
		for idx = #(stagePool["global"][AdvCodeRandomStage] or {}), 1, -1 do
			local c = stagePool["global"][AdvCodeRandomStage][idx] --  {room = roomId, block = blockId}
			if mapInfo.rooms[c["room"]]["event"][c["block"]] then -- 存在
				table.remove(stagePool["global"][AdvCodeRandomStage], idx)
			end
		end
		local ln = #(stagePool["global"][AdvCodeRandomStage] or {})
		local advMine = self.adv.owner:getProperty("advMine")
		advMine[1] = advMine[1] or {}
		local mineCh = advMine[1].ch or globalCsv.adv_egg_treasureMonster_showup
		local mineCo = advMine[1].co or {}
		local had = false
		if ln > 0 then
			if math.randomInt(1, 100) <= mineCh then -- 刷出来了
				local mpool = {}
				for _, mid in ipairs(globalCsv.adv_egg_treasureMonster_id) do
					local monster = csvdb["event_monsterCsv"][mid]
					if (not mineCo[mid] or monster.limit == 0 or mineCo[mid] < monster.limit) and monster.showup > 0 then
						mpool[mid] = {monster.showup}
					end
				end
				if next(mpool) then
					local idx = math.randomInt(1, ln)
					local cur = stagePool["global"][AdvCodeRandomStage][idx]
					giveEvent(cur["room"], cur["block"], AdvEventType.Monster, math.randWeight(mpool, 1))
					table.remove(stagePool["global"][AdvCodeRandomStage], idx)
					ln = ln - 1
					had = true
				end
			end
		end
		if had then
			mineCh = nil
		else
			mineCh = math.min(mineCh + globalCsv.adv_egg_treasureMonster_showup_add, 100)
		end
		advMine[1].ch = mineCh
		self.adv.owner:setProperty("advMine", advMine)
	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, AdvEventType.Monster, 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