local BattleSkillEntity = require "app/userdata/battle/skill/battle_skill_entity"

local BattleUnitEntity = class("BattleUnitEntity", BaseData)

function BattleUnitEntity:ctor()
end

function BattleUnitEntity:init(unitData, side, team)
	self.unitData = unitData
	self.side = side
	self.team = team
	self:initSkill()
end

function BattleUnitEntity:initSkill()
	self.activeSkills = {}
	if self.unitData.normalSkill then
		self.normalSkill = BattleSkillEntity:create(self.unitData.normalSkill, GConst.BattleConst.SKILL_TYPE_NORMAL, self)
	end
	if self.unitData.assistingSkill then
		self.assistingSkill = BattleSkillEntity:create(self.unitData.assistingSkill, GConst.BattleConst.SKILL_TYPE_ASSISTING, self)
	end
	if self.unitData.activeSkills then
		for k, v in ipairs(self.unitData.activeSkills) do
			local skill = BattleSkillEntity:create(v, GConst.BattleConst.SKILL_TYPE_ACTIVE, self)
			table.insert(self.activeSkills, skill)
		end
	end
end

function BattleUnitEntity:getIsBoss()
	return self.unitData.isBoss
end

function BattleUnitEntity:addSkill(skillId)
	local skillInfo = ConfigManager:getConfig("skill")[skillId]
	if skillInfo == nil then
		return nil
	end
	if skillInfo.effect_type == 1 then -- 主动技能
		local skill = BattleSkillEntity:create(skillId, GConst.BattleConst.SKILL_TYPE_ACTIVE, self)
		table.insert(self.activeSkills, skill)
		return skill
	else -- 被动技能
		if self.passiveSkills == nil then
			self.passiveSkills = {}
		end
		local skill = BattleSkillEntity:create(skillId, GConst.BattleConst.SKILL_TYPE_PASSIVE, self)
		table.insert(self.passiveSkills, skill)
		return skill
	end
	return nil
end

function BattleUnitEntity:removeSkill(skillId, sid)
	local skillInfo = ConfigManager:getConfig("skill")[skillId]
	if skillInfo == nil then
		return nil
	end
	if skillInfo.effect_type == 1 then -- 主动技能
		for k, v in ipairs(self.activeSkills) do
			if v:getSid() == sid then
				return table.remove(self.activeSkills, k)
			end
		end
	else -- 被动技能
		if self.passiveSkills then
			for k, v in ipairs(self.passiveSkills) do
				if v:getSid() == sid then
					return table.remove(self.passiveSkills, k)
				end
			end
		end
	end
	return nil
end

function BattleUnitEntity:addAttr(name, num, isPercent)
	return self.team:addAttr(name, num, isPercent)
end

function BattleUnitEntity:getModelId()
	return self.unitData.modelId
end

function BattleUnitEntity:getMatchType()
	return self.unitData.matchType
end

function BattleUnitEntity:getSide()
	return self.side
end

function BattleUnitEntity:setIsMainUnit(isMainUnit)
	self.isMainUnit = isMainUnit
end

function BattleUnitEntity:getIsMainUnit()
	return self.isMainUnit
end

function BattleUnitEntity:getNormalSkill()
	return self.normalSkill
end

function BattleUnitEntity:getAssistingSkill()
	return self.assistingSkill
end

function BattleUnitEntity:getActiveSkillCount()
	return #self.activeSkills
end

function BattleUnitEntity:getAvailableActiveSkill(index)
	local skill = self.activeSkills[index]
	if skill:getIsAvailable() then
		return skill
	end
	return nil
end

function BattleUnitEntity:getActiveSkill(index)
	return self.activeSkills[index]
end

function BattleUnitEntity:getNormalSkillCount()
	return self.unitData.normalSkillCount or 0
end

function BattleUnitEntity:getNormalSkillNameList()
	local count = self.unitData.normalSkillCount or 0
	if self.normalSkillNameList == nil then
		self.normalSkillNameList = {}
		for i = 1, count do
			table.insert(self.normalSkillNameList, DataManager.BattleData:getNormalAttackName(i))
		end
	end
	return self.normalSkillNameList, count
end

function BattleUnitEntity:getPassiveSkills()
	return self.passiveSkills
end

function BattleUnitEntity:changeActiveSkillId(originSkillId, tartgetSkillId)
	for _, skillEntity in ipairs(self.activeSkills) do
		if skillEntity:getSkillid() == originSkillId then
			skillEntity:changeSkillId(tartgetSkillId)
			local extraCount = self.skillExtraUseTimes[originSkillId]
			if extraCount then
				self.skillExtraUseTimes[tartgetSkillId] = extraCount
			end
			break
		end
	end
end

function BattleUnitEntity:addActiveSkillParams(skillId, effect)
	for _, skillEntity in ipairs(self.activeSkills) do
		if skillEntity:getSkillid() == skillId then
			skillEntity:addSkillEffectParams(effect)
			break
		end
	end
end

function BattleUnitEntity:addActiveSkillRound(skillId, effect)
	for _, skillEntity in ipairs(self.activeSkills) do
		if skillEntity:getSkillid() == skillId then
			skillEntity:addSkillEffectRound(effect)
			break
		end
	end
end

function BattleUnitEntity:takeDamageOrCure(num)
	return self.team:takeDamageOrCure(num)
end

function BattleUnitEntity:getHp()
	return self.team:getHp()
end

function BattleUnitEntity:getHpPercent()
	return self.team:getHpPercent()
end

function BattleUnitEntity:getAtk()
	return self.team:getAtk(self.unitData.matchType)
end

function BattleUnitEntity:getDmgAddition()
	return self.team:getDmgAddition(self.unitData.matchType)
end

function BattleUnitEntity:getDmgDec()
	return self.team:getDmgDec(self.unitData.matchType)
end

function BattleUnitEntity:getWeakness()
	return self.team:getWeakness(self.unitData.matchType)
end

function BattleUnitEntity:getCrit()
	return self.team:getCrit()
end

function BattleUnitEntity:getCrittime()
	return self.team:getCrittime()
end

function BattleUnitEntity:getCureAddition()
	return self.team:getCureAddition()
end

function BattleUnitEntity:getNormalAttackAddCount()
	return self.team:getNormalAttackAddCount()
end

function BattleUnitEntity:addLimit(name)
	self.team:addLimit(name)
end

function BattleUnitEntity:removeLimit(name)
	self.team:removeLimit(name)
end

function BattleUnitEntity:addShield(num)
	self.team:addShield(num)
end

function BattleUnitEntity:getShieldHp()
	return self.team:getShieldHp()
end

function BattleUnitEntity:addMaxHp(num)
	self.team:addMaxHp(num)
end

function BattleUnitEntity:addSkillExtraUseTimes(skillId, count)
	if self.skillExtraUseTimes == nil then
		self.skillExtraUseTimes = {}
	end
	self.skillExtraUseTimes[skillId] = (self.skillExtraUseTimes[skillId] or 0) + count
end

function BattleUnitEntity:getSkillExtraUseTimes(skillId)
	if self.skillExtraUseTimes == nil then
		return 0
	end
	return self.skillExtraUseTimes[skillId] or 0
end

function BattleUnitEntity:onRoundEnd()
	for k, v in ipairs(self.activeSkills) do
		v:cooldown()
	end
end

return BattleUnitEntity