local BaseRenda = {}
BaseRenda.__index = BaseRenda

function BaseRenda.new(index, path)
    local self = setmetatable({}, BaseRenda)
    self.name = "renda_" .. index
    self.path = path
    local screen_width = tex.get_screen_width()
    local screen_scale = tex.get_screen_scale()
    self.hori_move = anim.move(1500 * screen_scale, {total_distance = screen_width})
    self.hori_move:start()
    return self
end

function BaseRenda:update(current_time_ms)
    self.hori_move:update(current_time_ms)
end

local Renda0 = setmetatable({}, {__index = BaseRenda})
Renda0.__index = Renda0

function Renda0.new(index, path)
    local self = setmetatable({}, Renda0)
    local base = BaseRenda.new(index, path)
    for k, v in pairs(base) do self[k] = v end
    local screen_scale = tex.get_screen_scale()
    local screen_height = tex.get_screen_height()
    self.vert_move = anim.move(1500 * screen_scale, {total_distance = screen_height + (80 * screen_scale)})
    self.vert_move:start()
    local tex_info = tex.get_texture_info("renda", self.name)
    local num_frames = (tex_info and tex_info.frame_count) or 1
    self.frame = math.random(0, num_frames - 1)
    self.x = math.random(0, math.floor(500 * screen_scale))
    self.y = math.random(0, math.floor(20 * screen_scale))
    self._id = tex.get_texture(self.path .. "/renda/" .. self.name) or 0
    return self
end

function Renda0:update(current_time_ms)
    BaseRenda.update(self, current_time_ms)
    self.vert_move:update(current_time_ms)
end

function Renda0:draw()
    tex.draw_texture(self._id, {
        frame = self.frame,
        x = self.hori_move.attribute + self.x,
        y = -self.vert_move.attribute + self.y
    })
end

local Renda1 = setmetatable({}, {__index = BaseRenda})
Renda1.__index = Renda1

function Renda1.new(index, path)
    local self = setmetatable({}, Renda1)
    local base = BaseRenda.new(index, path)
    for k, v in pairs(base) do self[k] = v end
    local screen_scale = tex.get_screen_scale()
    local screen_height = tex.get_screen_height()
    self.frame = math.random(0, 5)
    self.y = math.random(0, math.floor(200 * screen_scale))
    self.rotate = anim.move(800 * screen_scale, {total_distance = math.floor(screen_height / 2), loop = true})
    self.rotate:start()
    self.origin = {64, 64}
    self._id = tex.get_texture(self.path .. "/renda/" .. self.name) or 0
    return self
end

function Renda1:update(current_time_ms)
    BaseRenda.update(self, current_time_ms)
    self.rotate:update(current_time_ms)
end

function Renda1:draw()
    tex.draw_texture(self._id, {
        frame = self.frame,
        x = self.hori_move.attribute + self.origin[1],
        y = self.y + self.origin[2],
        origin = self.origin,
        rotation = self.rotate.attribute
    })
end

local Renda2 = setmetatable({}, {__index = BaseRenda})
Renda2.__index = Renda2

function Renda2.new(index, path)
    local self = setmetatable({}, Renda2)
    local base = BaseRenda.new(index, path)
    for k, v in pairs(base) do self[k] = v end
    local screen_scale = tex.get_screen_scale()
    local screen_height = tex.get_screen_height()
    self.vert_move = anim.move(1500, {total_distance = screen_height + (80 * screen_scale)})
    self.vert_move:start()
    self.x = math.random(0, math.floor(500 * screen_scale))
    self.y = math.random(0, math.floor(20 * screen_scale))
    self._id = tex.get_texture(self.path .. "/renda/" .. self.name) or 0
    return self
end

function Renda2:update(current_time_ms)
    BaseRenda.update(self, current_time_ms)
    self.vert_move:update(current_time_ms)
end

function Renda2:draw()
    tex.draw_texture(self._id, {
        x = self.hori_move.attribute + self.x,
        y = -self.vert_move.attribute + self.y
    })
end

local RendaController = {}
RendaController.__index = RendaController

function RendaController.new(path, index)
    local self = setmetatable({}, RendaController)
    self.rendas = {}
    self.path = path or "background"
    self.index = (index ~= nil) and index or math.random(0, 2)
    tex.load_folder(self.path, "renda")
    return self
end

function RendaController:add_renda()
    local classes = {Renda0, Renda1, Renda2}
    local cls = classes[self.index + 1]
    table.insert(self.rendas, cls.new(self.index, self.path))
end

function RendaController:update(current_time_ms)
    for i = #self.rendas, 1, -1 do
        self.rendas[i]:update(current_time_ms)
        if self.rendas[i].hori_move.is_finished then
            table.remove(self.rendas, i)
        end
    end
end

function RendaController:draw()
    for _, renda in ipairs(self.rendas) do
        renda:draw()
    end
end

function RendaController:destroy()
    tex.unload_folder(self.path, "renda")
end

return RendaController