local log = require("log")

---@class ow.Plugin.Spec
---@field [1] string
---@field name? string
---@field version? string | vim.VersionRange
---@field lazy? boolean
---@field build? string[] | fun(self: ow.Plugin): boolean

---@class ow.Plugin : ow.Plugin.Spec
---@field path string

---@type ow.Plugin[]
local plugins = {}

---@param plugin ow.Plugin
local function load(plugin)
    vim.cmd.packadd(plugin.name)

    local name = plugin.name:match("[^.]+"):lower()
    local path = string.format(
        "%s/lua/plugins/%s.lua",
        vim.fn.stdpath("config"),
        name
    )

    if vim.uv.fs_stat(path) then
        local ok, err = pcall(dofile, path)
        if not ok then
            log.error("Failed to load %s: %s", name, err)
        end
    end
end

---@param spec string | ow.Plugin.Spec
---@return vim.pack.Spec
local function to_pack_spec(spec)
    if type(spec) == "string" then
        return { src = spec }
    end

    return {
        src = spec[1],
        name = spec.name,
        version = spec.version,
        data = {
            lazy = spec.lazy,
            build = spec.build,
        },
    }
end

---@param plugin ow.Plugin
---@return boolean success
local function run_build(plugin)
    if type(plugin.build) == "function" then
        return plugin.build(plugin)
    elseif type(plugin.build) == "table" then
        local ret = vim.system(
            plugin.build --[[@as table]],
            { cwd = plugin.path }
        ):wait()
        return ret.code == 0 and ret.signal == 0
    end

    log.error("invalid build parameter for %s", plugin.name)
    return false
end

---@class ow.Plugin.PackEvent.Data
---@field active boolean
---@field kind "install" | "update" | "delete"
---@field spec vim.pack.Spec
---@field path string

---@class ow.Plugin.PackEvent : vim.api.keyset.create_autocmd.callback_args
---@field data ow.Plugin.PackEvent.Data

---@param plugin ow.Plugin
---@param events ow.Plugin.PackEvent[]
---@return boolean success
local function handle_pack_events(plugin, events)
    if not plugin.build then
        return true
    end

    for _, ev in ipairs(events) do
        if ev.data.spec.name == plugin.name
            and ev.event == "PackChanged"
            and (ev.data.kind == "install" or ev.data.kind == "update")
        then
            vim.cmd.packadd(plugin.name)
            return run_build(plugin)
        end
    end

    return true
end

local M = {}

function M.get_paths()
    local paths = {}

    for _, plugin in ipairs(plugins) do
        table.insert(paths, plugin.path)
    end

    return paths
end

---@param specs (string | ow.Plugin.Spec)[]
function M.setup(specs)
    ---@type ow.Plugin.PackEvent[]
    local events = {}
    local id = vim.api.nvim_create_autocmd(
        { "PackChangedPre", "PackChanged" },
        {
            ---@param ev ow.Plugin.PackEvent
            callback = function(ev)
                table.insert(events, ev)
            end
        }
    )
    vim.pack.add(vim.tbl_map(to_pack_spec, specs), {
        load = function(data)
            local d = data.spec.data or {}
            ---@type ow.Plugin
            local plugin = {
                [1] = data.spec.src,
                name = data.spec.name,
                version = data.spec.version,
                lazy = d.lazy or false,
                build = d.build,
                path = data.path,
            }
            table.insert(plugins, plugin)
        end
    })
    vim.api.nvim_del_autocmd(id)

    local lazy_plugins = {}
    for _, plugin in ipairs(plugins) do
        if not handle_pack_events(plugin, events) then
            return
        end

        if plugin.lazy then
            table.insert(lazy_plugins, plugin)
        else
            load(plugin)
        end
    end

    vim.api.nvim_create_autocmd("UIEnter", {
        once = true,
        callback = vim.schedule_wrap(function()
            for _, plugin in ipairs(lazy_plugins) do
                load(plugin)
            end
        end)
    })
end

return M