async.lua

if not love.thread then
    LOG("ASYNC lib is not loaded (need love.thread)")
    return setmetatable({},{
        __index=function(_,k)
            error("attempt to use ASYNC."..k..", but ASYNC lib is not loaded (need love.thread)")
        end,
    })
end

local resPool={}
local flagPool={}

local ASYNC={}

local resCHN=love.thread.newChannel()
local getCount=resCHN.getCount

---@type Map<love.Thread>
local threads={}

local function refreshThreads()
    for k,v in next,threads do
        if not v:isRunning() then
            threads[k]=nil
        end
    end
end

---@language LUA
local thread_lua=[[
    local resCHN,rtn,cmd,args,traceback=...

    local func,err=loadstring(cmd,"<async>"..tostring(rtn))
    if func then
        local suc, res = pcall(func, args)
        if suc then
            resCHN:push({
                rtn=rtn,
                res=res,
            })
        else
            resCHN:push({
                rtn=rtn,
                err=traceback:gsub('@@@',res),
            })
        end
    else
        resCHN:push({
            rtn=rtn,
            err=traceback:gsub('@@@',err),
        })
    end
]]
---Run a Lua function asynchronously in another Love2D thread
---
---Note: multiple calls with same `rtn` will override each other, only the latest result will be kept.
---@param rtn string | any Use ASYNC.get(rtn) to get the result later
---@param cmd string Lua code string (cannot be function because cannot pass non-data objects to Love2D thread)
---@param args? any parameter to pass to the Lua code
---@return boolean success whether the thread was started
function ASYNC.runLua(rtn,cmd,args)
    refreshThreads()
    if threads[rtn] then return false end
    flagPool[rtn]=true
    threads[rtn]=love.thread.newThread(thread_lua)
    threads[rtn]:start(
        resCHN,
        rtn,
        cmd,
        args,
        debug.traceback('@@@',2)
    )
    return true
end

---@language BAT|SH
local thread_cmd=[[
    local resCHN,rtn,cmd=...

    local f=io.popen(cmd,'r')
    local res=f:read('*a')
    f:close()

    resCHN:push{
        rtn=rtn,
        res=res,
    }
]]
---Run a system command asynchronously in another Love2D thread
---
---Note: multiple calls with same `rtn` will override each other, only the latest result will be kept.
---@param rtn string | any Use ASYNC.get(rtn) to get the result later
---@param cmd string command to run with io.popen
---@return boolean success whether the thread was started
function ASYNC.runCmd(rtn,cmd)
    refreshThreads()
    if threads[rtn] then return false end
    flagPool[rtn]=true
    threads[rtn]=love.thread.newThread(thread_cmd)
    threads[rtn]:start(
        resCHN,
        rtn,
        cmd
    )
    return true
end

local function update()
    while getCount(resCHN)>0 do
        local m=resCHN:pop()
        if m.err then
            LOG('error',m.err)
        else
            resPool[m.rtn]=m.res
            flagPool[m.rtn]=true
        end
    end
end

---Get the result of an asynchronous operation started with ASYNC.runLua or ASYNC.runCmd
---@param rtn string | any The return key used in ASYNC.runLua or ASYNC.runCmd
function ASYNC.get(rtn)
    refreshThreads()
    update()

    if resPool[rtn]~=nil then
        local res=resPool[rtn]
        resPool[rtn]=nil
        flagPool[rtn]=nil
        return res
    end
end

---Check if the result of an asynchronous operation is retrieved, to avoid multiple ASYNC.run('task1') overriding each other's result
---
---`true` since ASYNC.run(), `false` after ASYNC.get()
---@param rtn string | any
---@return true?
function ASYNC.isBusy(rtn)
    update()
    return flagPool[rtn]
end

return ASYNC