local utils = require "lib.utils.utils"

--- @class Effect
--- @field tag string
local effect = {}
effect.__index = effect

--- @alias EffectFunc fun(owner: Character): Task<nil>|nil
--- @alias EffectDamageFunc fun(owner: Character, damage: integer): Task<nil>|nil
--- @alias EffectRegenFunc fun(owner: Character, amountHp: integer): Task<nil>|nil
--- @alias EffectData { tag: string, [string]: EffectFunc|EffectDamageFunc|EffectRegenFunc }

--- @param owner Character
--- @return Task<nil>|nil
function effect:beforeBirth(owner) end

--- @param owner Character
--- @return Task<nil>|nil
function effect:afterBirth(owner) end

--- @param owner Character
--- @return Task<nil>|nil
function effect:beforeDeath(owner) end

--- @param owner Character
--- @return Task<nil>|nil
function effect:afterDeath(owner) end

--- пока что это единственный метод, который работает
--- @param owner Character
--- @return Task<nil>|nil
function effect:beforeTurn(owner) end

--- @param owner Character
--- @return Task<nil>|nil
function effect:afterTurn(owner) end

--- @param owner Character
--- @return Task<nil>|nil
function effect:beforeCast(owner) end

--- @param owner Character
--- @return Task<nil>|nil
function effect:afterCast(owner) end

--- @param owner Character
--- @param damage integer
--- @return Task<nil>|nil
function effect:beforeAttack(owner, damage) end

--- @param owner Character
--- @return Task<nil>|nil
function effect:afterAttack(owner) end

--- @param owner Character
--- @param damage integer
--- @return Task<nil>|nil
function effect:beforeDamage(owner, damage) end

--- @param owner Character
--- @return Task<nil>|nil
function effect:afterDamage(owner) end

--- @param owner Character
--- @param amountHp integer кол-во хп для регена
--- @return Task<nil>|nil
function effect:beforeRegeneration(owner, amountHp) end

--- @param owner Character
--- @return Task<nil>|nil
function effect:afterRegeneration(owner) end

--- @param other Effect
--- @return Effect|nil
function effect:sum(other) end

function effect:update(dt) end

function effect:draw() end

--- дип сравнение эффектов
--- @param other Effect
--- @return boolean
function effect:__eq(other)
    return utils.deepComprasion(self, other)
end

--- @todo переделать дату и прочее
-- --- @param data {tag: string, beforeBirth: fun(owner: Character)?, beforeDeath: fun(owner: Character)?, beforeTurn: (fun(owner: Character): Task<nil>|nil), afterTurn: (fun(owner: Character): Task<nil>|nil), sum: fun(owner: Character)?}
--- @param data EffectData
--- @return Effect
local function new(data)
    local newEffect = setmetatable({
        tag = data.tag
    }, effect)

    function newEffect:beforeBirth(owner)
        if not data.beforeBirth then return end
        return data.beforeBirth(owner)
    end

    function newEffect:afterBirth(owner)
        if not data.afterBirth then return end
        return data.afterBirth(owner)
    end

    function newEffect:beforeDeath(owner)
        if not data.beforeDeath then return end
        return data.beforeDeath(owner)
    end

    function newEffect:afterDeath(owner)
        if not data.afterDeath then return end
        return data.afterDeath(owner)
    end

    function newEffect:beforeTurn(owner)
        if not data.beforeTurn then return end
        return data.beforeTurn(owner)
    end

    function newEffect:afterTurn(owner)
        if not data.afterTurn then return end
        return data.afterTurn(owner)
    end

    function newEffect:beforeCast(owner)
        if not data.beforeCast then return end
        return data.beforeCast(owner)
    end

    function newEffect:afterCast(owner)
        if not data.afterCast then return end
        return data.afterCast(owner)
    end

    function newEffect:beforeAttack(owner, damage)
        if not data.beforeAttack then return end
        return data.beforeAttack(owner, damage)
    end

    function newEffect:afterAttack(owner)
        if not data.afterAttack then return end
        return data.afterAttack(owner)
    end

    function newEffect:beforeDamage(owner, damage)
        if not data.beforeDamage then return end
        return data.beforeDamage(owner, damage)
    end

    function newEffect:afterDamage(owner)
        if not data.afterDamage then return end
        return data.afterDamage(owner)
    end

    function newEffect:beforeRegeneration(owner, amountHp)
        if not data.beforeRegeneration then return end
        return data.beforeRegeneration(owner, amountHp)
    end

    function newEffect:afterRegeneration(owner)
        if not data.afterRegeneration then return end
        return data.afterRegeneration(owner)
    end

    --- дип сравнение эффектов
    --- @param other Effect
    --- @return boolean
    function newEffect:__eq(other)
        return utils.deepComparison(self, other)
    end

    return newEffect
end

return { new = new }