local BattleData = class("BattleData", BaseData)

local BattleConst = GConst.BattleConst
local BATTLE_GRID_ENTITY = require "app/userdata/battle/battle_grid_entity"
local BATTLE_CARD_SKILL_ENTITY = require "app/userdata/battle/skill/battle_card_skill_entity"

function BattleData:init(board)
    self:clear()

    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
end

function BattleData:clear()
    self:clearGridSequence()

    self.gridEntities = {}
    self.elementTypeMap = {} -- 同元素得格子数量
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: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)
    self.skillInfluenceGrids = grids
end

function BattleData:getSkillInfluenceGrids()
    return self.skillInfluenceGrids
end

function BattleData:clearGridSequence()
    self.gridSequence = {} -- 格子队列
    self.gridSequenceMap = {} -- 格子队列对应的map，方面查找
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
end

return BattleData