local RawData = Object:extend()
local DataList = Object:extend()

local ListHolder = require "classes.dataholders.listholder"
local SimpleHolder = require "classes.dataholders.simpleholder"

function RawData.fromLine(line)
    line = utils.removeComment(line)
    if (#line == 0) then
        return nil
    end
    local command = utils.split(line, "|")
    local datas = utils.split(utils.trim(command[1]), ";")
    local args = {}
    name = utils.trim(datas[1])
    for i, v in ipairs(datas) do
        if (i > 1) then
            table.insert(args, utils.trim(v))
        end
    end
    local level = 0
    if (command[2] ~= nil)  then
        levelString = utils.trim(command[2]);
        level = tonumber(levelString) or 0
    end
    return RawData(name, commands.clean(args, name), level)
end

function RawData:new(name, arguments, level)
    self.name = name
    self.arguments = arguments
    self.level = level
end

function RawData:canBeUsed(level)
    return level >= self.level
end

function RawData:getKey()
    return utils.split(self.name, ".", true)[1]
end

function RawData:getCommand()
    return utils.split(self.name, ".", true)[2] or ""
end

function DataList.getHolder(key, value)
    if (value.dataType == "comp" or value.dataType == "list") then
        print("list", key, value)
        return ListHolder(key, value)
    end
    print("simple", key, value.dataType)
    return SimpleHolder(key, value)
end

function DataList:new()
    self.list = {}
    self.holders = {}
    self.reducedList = {}
    for key, value in pairs(commands.getDefaults()) do
        table.insert(self.list, RawData(key, value, 0))
    end
    for key, struct in pairs(commands.structs) do
        self.holders[key] = DataList.getHolder(key, struct)
    end
end

function DataList:addLine(line)
    table.insert(self.list, RawData.fromLine(line))
end

function DataList:reduce()
    local level = 0
    for _, rawdata in ipairs(self.list) do
        if (rawdata.name == "level") then
            rawdata = rawdata.arguments
        end
    end

    for _, rawdata in ipairs(self.list) do
        if (rawdata:canBeUsed(level)) then
            self.holders[rawdata:getKey()]:applyCommand(rawdata:getCommand(), rawdata.arguments)
        end
    end

    for key, holder in pairs(self.holders) do
        self.reducedList[key] = holder:reduce(level)
    end

    --TODO
end

function DataList:prepareJson()
    self:reduce()
    return self.reducedList
end

return DataList