local Passive = class("Passive")
  
  -- 每回合触发的使用 afterRound
  -- 其他触发的使用 triggerPassive 
  

  Passive.BORN_ONCE = 1 -- 自身出生（翻开所在格子）触发
  Passive.ROOM_SHOW = 2 --自身所在房间被展示时，触发1次 

  Passive.HURT_PERCENT_SELF = 3 --自身，每损失N%生命值，触发1次
  Passive.HURT_PERCENT_TEAM = 4 --队友，每损失N%生命值，触发1次
  Passive.HP_LOW_SELF = 5 --自身生命值<N%时，每回合触发
  Passive.HP_LOW_TEAM = 6 --敌人生命值<N%时，每回合触发
  Passive.HP_UP_SELF = 7 --自身生命值>N%时，每回合触发
  Passive.HP_UP_TEAM = 8 --敌人生命值>N%时，每回合触发
  Passive.SELF_ATK = 9 --自身攻击N次后，触发1次
  Passive.SELF_HURT = 10 --自身受击N次后，触发1次
  Passive.TEAM_ATK = 11 --队友攻击N次后，触发1次
  Passive.TEAM_HURT = 12 --队友受击N次后，触发1次
  Passive.MONSTER_COUNT_UP = 13  --场上存在N个以上怪物，每回合触发
  Passive.MONSTER_COUNT_LOW = 14  --场上存在N个以下怪物，每回合触发
  Passive.SELF_DEAD = 15 --自身死亡后，触发1次
  Passive.TEAM_DEAD = 16 --队友死亡后，触发1次
  Passive.TARGET_SKILL = 17 --目标每使用N次技能，触发1次
  Passive.TEAM_SKILL = 18 --队友每使用N次技能，触发1次

  
  -- 不同的开启条件

  local PassiveCondFactory = {}
  PassiveCondFactory[Passive.HURT_PERCENT_SELF] = function(_Passive)
  	_Passive._trigger = function(self, params)
  		local value = params.value or 1
  		self.rv = math.floor(self.rv + value)
  		if self.rv >= self.passiveData.value then
  			self.rv = self.rv % self.passiveData.value  -- 取余
  			return true
  		end
  	end
  	_Passive._initDB = function(self, data)
  		self.rv = data.rv or 0
  	end
  	_Passive._getDB = function(self)
  		return {rv = self.rv}
  	end
  end
  
  PassiveCondFactory[Passive.HURT_PERCENT_TEAM] = PassiveCondFactory[Passive.HURT_PERCENT_SELF]  --逻辑相同
  PassiveCondFactory[Passive.SELF_ATK] = PassiveCondFactory[Passive.HURT_PERCENT_SELF]  --逻辑相同
  PassiveCondFactory[Passive.SELF_HURT] = PassiveCondFactory[Passive.HURT_PERCENT_SELF]  --逻辑相同
  PassiveCondFactory[Passive.TEAM_ATK] = PassiveCondFactory[Passive.HURT_PERCENT_SELF]  --逻辑相同
  PassiveCondFactory[Passive.TEAM_HURT] = PassiveCondFactory[Passive.HURT_PERCENT_SELF]  --逻辑相同
  PassiveCondFactory[Passive.TARGET_SKILL] = PassiveCondFactory[Passive.HURT_PERCENT_SELF]  --逻辑相同
  PassiveCondFactory[Passive.TEAM_SKILL] = PassiveCondFactory[Passive.HURT_PERCENT_SELF]  --逻辑相同
  
  PassiveCondFactory[Passive.ROOM_SHOW] = function(_Passive)
  	_Passive._trigger = function(self, params)
  		local roomId = params.roomId
  		if self.roomId == roomId then
  			return true
  		end
  	end
  end
  
  PassiveCondFactory[Passive.HP_LOW_SELF] = function(_Passive)
  	_Passive._afterRound = function(self)
  		if self.owner.hp / self.owner.hpMax * 100 < self.passiveData.value then
  			self:trigger(Passive.HP_LOW_SELF)
  		end
  	end
  end
  
  PassiveCondFactory[Passive.HP_LOW_TEAM] = function(_Passive)
  	_Passive._afterRound = function(self)
  		for _, player in ipairs(self.owner:getTeam(2)) do
  			if player.hp / player.hpMax * 100 < self.passiveData.value then
  				self:trigger(Passive.HP_LOW_TEAM, {trigger = player})
  			end
  		end
  	end
  end
  
  PassiveCondFactory[Passive.HP_UP_SELF] = function(_Passive)
  	_Passive._afterRound = function(self)
  		if self.owner.hp / self.owner.hpMax * 100 > self.passiveData.value then
  			self:trigger(Passive.HP_UP_SELF)
  		end
  	end
  end
  
  PassiveCondFactory[Passive.HP_UP_TEAM] = function(_Passive)
  	_Passive._afterRound = function(self)
  		for _, player in ipairs(self.owner:getTeam(2)) do
  			if player.hp / player.hpMax * 100 > self.passiveData.value then
  				self:trigger(Passive.HP_UP_TEAM, {trigger = player})
  			end
  		end
  	end
  end
  
  PassiveCondFactory[Passive.MONSTER_COUNT_UP] = function(_Passive)
  	_Passive._afterRound = function(self)
  		local monsters = self.owner.battle.player:getTeam(2)
  		if #monsters > self.passiveData.value then
  			self:trigger(Passive.MONSTER_COUNT_UP)
  		end
  	end
  end
  
  PassiveCondFactory[Passive.MONSTER_COUNT_LOW] = function(_Passive)
  	_Passive._afterRound = function(self)
  		local monsters = self.owner.battle.player:getTeam(2)
  		if #monsters < self.passiveData.value then
  			self:trigger(Passive.MONSTER_COUNT_LOW)
  		end
  	end
  end
  

  
  function Passive:ctor(owner, data)
  	self.owner = owner
  	self.id = data.id
  	self.level = data.level or 1
  	self.passiveData = csvdb["adv_skill_passiveCsv"][self.id][self.level]
  	self.isDel = false
  	self.round = data.round or 0	--触发剩余回合数
  	self.count = data.count or 0	--触发剩余次数

  	if PassiveCondFactory[self.passiveData.condition] then
  		PassiveCondFactory[self.passiveData.condition](self)
  	end
  	if self._initDB then
  		self:_initDB(data)

  	end
  end
  
  function Passive:getCondType()
  	return self.passiveData.condition, self.passiveData.value
  end
  
  function Passive:effect()

  	if math.randomInt(1, 100) <= self.passiveData.chance and self["effect" .. self.passiveData.effect] then
  		self["effect" .. self.passiveData.effect](self) 

  	end
  	--次数为 -1 一局只能触发一次，触发过后删掉就可以
  	if self.count == -1 then
  		self.isDel = true
  	end
  	if self.count > 0 then
  		self.count = self.count - 1
  		self.round = self.passiveData.space
  	end
  end
  
  function Passive:afterRound()
  	if self.isDel or self.owner.isDead then return end
  	if self._afterRound then
  		self:_afterRound()  --有的触发自己检测在这里检查
  	end
  	if self.round > 0 then  --回合触发的
  		self.round = self.round - 1
  		if self.round == 0 then
  			self:effect()
  		end
  	end
  end
  
  -- 正在触发中
  function  Passive:isActive( )
  	return self.count > 0 or self.round > 0
  end
  
  function Passive:trigger(condType, params) --触发检查

  	params = params or {}
  	if self.isDel or self.owner.isDead then return end

  	if self:getCondType() ~= condType then return end

  	if self.owner.lock and self.passiveData.effect ~= 3 then return end -- 锁定的只能触发翻开自己格子的固有技

  	if self:isActive() then return end

  	if self._trigger then

  		if not self:_trigger(params) then return end  --检查

  	end

  	self.round = self.passiveData.delay --首次
  	self.count = self.passiveData.count --次数
  	-- 没有延迟就直接触发
  	if self.round == 0 then

  		self:effect(params.trigger)

  	end
  end
  
  function Passive:getDB()
  	local db = {}
  	if self._getDB then
  		db = self:_getDB()
  	end
  	db.id = self.id
  	db.level = self.level
  	db.round = self.round
  	db.count = self.count

  	return db

  end

  
  --默认=0=使用技能，
  function Passive:effect0()
  	self.owner:releaseSkill(self.passiveData.effectValue)
  end
  --1=自身获得buff
  function Passive:effect1()
  	self.owner:addBuff(self.passiveData.effectValue)
  end
  --2=触发目标获得buff
  function Passive:effect2(trigger)
  	if trigger then
  		trigger:addBuff(self.passiveData.effectValue)
  	end
  end
  --3=翻开自己所在格子，
  function Passive:effect3()
  	self.owner.battle.adv:openBlock(self.owner.roomId, self.owner.blockId)
  end
  --4=逃跑
  function Passive:effect4()
  	self.owner.isDead = true --跑了
  	self.owner.battle.adv:enemyDead(self.owner.roomId,self.owner.blockId, true)
  end
  
  

  return Passive