local BattleTeamEntity = require "app/userdata/battle/team/battle_team_entity"

local BattleData = class("BattleData", BaseData)

local SKILL_HERO_CFG = ConfigManager:getConfig("skill_hero")
local BattleConst = GConst.BattleConst
local BATTLE_GRID_ENTITY = require "app/userdata/battle/battle_grid_entity"
local BATTLE_BOARD_SKILL_ENTITY = require "app/userdata/battle/skill/battle_borad_skill_entity"

local ATTR_TYPE = GConst.ATTR_TYPE
local DEFAULT_FACTOR = GConst.DEFAULT_FACTOR

function BattleData:init(board, skillIds, skillPool)
    self:clear()
    self.atkTeam = self:initTeam(BattleConst.SIDE_ATK)
    self.defTeam = self:initTeam(BattleConst.SIDE_DEF)

    for i, info in ipairs(board) do
        local r = 1
        local c = 1
        local zheng = i // BattleConst.ROW_COUNT
        local yu = i % BattleConst.ROW_COUNT
        if yu > 0 then
            r = zheng + 1
            c = yu
        else
            r = zheng
            c = BattleConst.ROW_COUNT
        end

        local posId = ModuleManager.BattleManager:getPosId(r, c)
        local data = {
            posId = posId,
            gridType = info[1],
            elementType = info[2]
        }
        self.gridEntities[data.posId] = BATTLE_GRID_ENTITY:create(data)
        if self.gridEntities[data.posId]:canLink() then
            self.elementTypeMap[data.elementType] = (self.elementTypeMap[data.elementType] or 0) + 1
        end
    end

    --- todo
    skillIds = {
        10, 21, 30, 40, 50
    }
    for _, skillId in ipairs(skillIds) do
        local cfg = SKILL_HERO_CFG[skillId]
        self.skillMap[cfg.position] = BATTLE_BOARD_SKILL_ENTITY:create(skillId)
    end

    ---- skillPool
    self.skillPool = skillPool or {200301}
end

function BattleData:clear()
    self:clearGridSequence()

    self.gridEntities = {}
    self.elementTypeMap = {} -- 同元素得格子数量
    self.skillMap = {}
    self.selectSkillMap = {}
end

function BattleData:getElementTypeMap()
    return self.elementTypeMap
end

function BattleData:getGridSequence()
    return self.gridSequence
end

function BattleData:alreadyInsertSequence(posId)
    return self.gridSequenceMap[posId] == true
end

function BattleData:getSequenceHadSkill()
    for _, info in ipairs(self:getGridSequence()) do
        local entity = self.gridEntities[info.posId]
        if entity and entity:getSkillId() then
            return true
        end
    end
    return false
end

function BattleData:insertGridSequence(posId, snapshot)
    if self:alreadyInsertSequence(posId) then
        return false
    end

    self.gridSequenceMap[posId] = true
    table.insert(self.gridSequence, {posId = posId, snapshot = snapshot})
    return true
end

function BattleData:removeGridSequence(posId)
    if not self:alreadyInsertSequence(posId) then
        return
    end

    local count = #self.gridSequence
    local lastPosId = self.gridSequence[count].posId
    local snapshot = self.gridSequence[count].snapshot
    if lastPosId ~= posId then
        return
    end

    table.remove(self.gridSequence, count)
    self.gridSequenceMap[lastPosId] = false
    return snapshot
end

function BattleData:cacheSkillInfluenceGrids(grids)
    if not self.skillInfluenceGrids then
        self.skillInfluenceGrids = {}
    end
    for posId, status in pairs(grids) do
        self.skillInfluenceGrids[posId] = true
    end
end

function BattleData:getSkillInfluenceGrids()
    return self.skillInfluenceGrids or {}
end

function BattleData:clearSkillInfluenceGrids()
    local grids = self:getSkillInfluenceGrids()
    self.skillInfluenceGrids = {} -- 技能影响的格子
    return grids
end

function BattleData:clearGridSequence()
    self.gridSequence = {} -- 格子队列
    self.gridSequenceMap = {} -- 格子队列对应的map，方面查找
    self:clearSkillInfluenceGrids()
end

function BattleData:getGridEnties()
    return self.gridEntities
end

function BattleData:getGridEntity(posId)
    return self.gridEntities[posId]
end

function BattleData:exchangeGridEntities(posId1, posId2)
    local e1 = self.gridEntities[posId1]
    local e2 = self.gridEntities[posId2]
    e1:setPosId(posId2)
    e2:setPosId(posId1)
    e2:setIsIdle(false)
    self.gridEntities[posId1] = e2
    self.gridEntities[posId2] = e1
end

function BattleData:setGridInfo(posId, gridInfo)
    local entity = self.gridEntities[posId]
    if not entity then
        return
    end

    if entity:canLink() then
        local elementType = entity:getElementType()
        self.elementTypeMap[elementType] = (self.elementTypeMap[elementType] or 0) - 1
        if self.elementTypeMap[elementType] < 0 then
            self.elementTypeMap[elementType] = 0
        end
    end

    if gridInfo.gridType then
        entity:setGridType(gridInfo.gridType)
    end

    if gridInfo.elementType then
        entity:setElementType(gridInfo.elementType)
        if entity:canLink() then
            self.elementTypeMap[gridInfo.elementType] = (self.elementTypeMap[gridInfo.elementType] or 0) + 1
        end
    end

    entity:setSkilId() -- 清除skillId
end

function BattleData:getSkillElementList(elementType, count, useAlternate)
    local result = {}
    if not self.gridEntities then
        return result
    end

    local sameElementList = {}
    local alternateList = {}
    local addCount = 0

    for row = 1, BattleConst.ROW_COUNT do
        for column = 1, BattleConst.COLUMN_COUNT do
            local posId = ModuleManager.BattleManager:getPosId(row, column)
            local entity = self.gridEntities[posId]
            if entity and entity:canChangeInfo() then
                if entity:getElementType() == elementType then
                    table.insert(sameElementList, posId)
                else
                    table.insert(alternateList, posId)
                end
            end
        end

        local remainCount = count - addCount
        if remainCount <= 0 then
            return result
        end

        for i = 1, remainCount do
            if not sameElementList[i] then
                break
            end
            table.insert(result, table.remove(sameElementList, math.random(1, #sameElementList)))
            addCount = addCount + 1
            if addCount >= count then
                return result
            end
        end

        if addCount < count and useAlternate then
            for i = 1, count - addCount do
                if not alternateList[1] then
                    break
                end
                table.insert(result, table.remove(alternateList, math.random(1, #alternateList)))
                addCount = addCount + 1
                if addCount >= count then
                    return result
                end
            end
        end

        if addCount >= count then
            return result
        end
    end

    return result
end

function BattleData:getSkillEntities()
    return self.skillMap
end

function BattleData:getSkillEntityByElement(elementType)
    if not self.skillMap then
        return
    end
    return self.skillMap[elementType]
end

function BattleData:getSkillEntityBySkillId(skillId)
    if not self.skillMap or not skillId then
        return
    end
    local cfg = SKILL_HERO_CFG[skillId]
    if not cfg then
        return
    end
    return self.skillMap[cfg.position]
end

function BattleData:addSkillEnergy(elementMap)
    if not self.skillMap then
        return
    end

    for elementType, entity in pairs(self.skillMap) do
        entity:addEnergy(elementMap[elementType] or 0)
    end
end

function BattleData:addSkillCount(skillId)
    if not self.selectSkillMap[skillId] then
        self.selectSkillMap[skillId] = 0
    end
    self.selectSkillMap[skillId] = self.selectSkillMap[skillId] + 1
end

function BattleData:getSkillCount(skillId)
    return self.selectSkillMap[skillId] or 0
end

function BattleData:getSkillPool()
    return self.skillPool
end

function BattleData:changeSkillId(originId, newId)
    if not newId then
        return
    end

    local entity = DataManager.BattleData:getSkillEntityBySkillId(originId)
    if entity then
        entity:refreshSkillId(newId)
    end
end

function BattleData:initTeam(side)
    local data = nil
    if side == BattleConst.SIDE_ATK then
        data = self:initHeroData()
    end
    local team = BattleTeamEntity:create()
    team:init(side, data)
    return team
end

function BattleData:getAtkTeam()
    return self.atkTeam
end

function BattleData:getDefTeam()
    return self.defTeam
end

function BattleData:initHeroData()
    local units = {}
	local formation = DataManager.FormationData:getStageFormation()
	for matchType, heroId in pairs(formation) do
		if heroId > 0 then
			local heroEntity = DataManager.HeroData:getHeroById(heroId)
			if heroEntity then
				local heroAttr = heroEntity:getAllAttr()
				local activeSkill = heroEntity:getActiveSkill()					    -- 主动技能
				local hp = heroAttr[ATTR_TYPE.hp] // DEFAULT_FACTOR
				local unitData = {
					id = heroId,
					modelId = heroEntity:getModelId(),
					level = heroEntity:getLv(),
                    qlt = heroEntity:getQlt(),
                    matchType = matchType,
                    activeSkill = activeSkill,
					attr = {
						hp = hp,
						max_hp = hp,
						atk = heroAttr[ATTR_TYPE.atk] // DEFAULT_FACTOR,
					}
				}
				table.insert(units, unitData)
			end
		end
	end
	local data = {
		units = units
	}
	return data
end

return BattleData