--[[pod_format="raw",created="2024-04-09 22:52:04",modified="2024-04-11 17:26:16",revision=1003]]
-- abledbody's profiler v1.1

local function do_nothing() end

-- The metatable here is to make profile() possible.
-- Why use a table at all? Because otherwise lua will try to cache the function call,
-- which by default is do_nothing.
local profile_meta = {__call = do_nothing}
profile = {draw = do_nothing}
setmetatable(profile,profile_meta)

local running = {} -- All incomplete profiles
 -- All complete profiles. Note that if the profiles haven't been drawn yet, it will
 -- not be cleared, and further profiles of the same name will add to the usage metric.
local profiles = {}
-- All completed lingering profiles. These are never automatically cleared.
local lingers = {}

-- start_profile, stop_profile, and stop_linger are all internal functions,
-- serving as paths for _profile to take. Lingers share start_profile.
local function start_profile(name,linger)
    local source = profiles[name]
    running[name] = {
        linger = linger,
    }
    local active = running[name]
    active.start = stat(1) --Delaying CPU usage grab until the last possible second.
end

local function stop_profile(name,active,delta)
    local profile = profiles[name]
    if profile then
        profile.time = delta+profile.time
    else
        profiles[name] = {
            time = delta,
            name = name,
        }
        add(profiles,profiles[name])
    end
end

local function stop_linger(name,active,delta)
    local profile = lingers[name]
    if profile then
        profile.time = profile.this_frame and delta+profile.time or delta
        profile.this_frame = true
    else
        lingers[name] = {
            time = delta,
            this_frame = true,
        }
    end
end

-- The main functionality lives here.
-- Takes in the name of what you're profiling, and whether or not to
-- make the profile linger.
local function _profile(_,name,linger)
    local t = stat(1)
    local active = running[name]
    if active then
        local delta = t-active.start

        if active.linger then stop_linger(name,active,delta)
        else stop_profile(name,active,delta) end

        running[name] = nil
    else
        start_profile(name,linger)
    end
end

-- Clears all lingering profiles.
function profile.clear_lingers()
    lingers = {}
end

local function draw_cpu()
    print("cpu:"..string.sub(stat(1)*100,1,5).."%",1,1,7)
end

-- This draws the profiles, and then resets everything for the next frame.
-- If it is not called, usage metrics will accumulate.
-- Lingering profiles are always displayed after persistent profiles.
local function display_profiles()
    local i = 1
    for prof in all(profiles) do
        local usage = string.sub(prof.time*100,1,5).."%"
        local to_print = prof.name..":"..usage
        print(to_print,1,1+i*9,7)
        i = i+1
    end
    for name,prof in pairs(lingers) do
        local usage = string.sub(prof.time*100,1,5).."%"
        local to_print = name..(prof.this_frame and "[X]:" or "[ ]:")..usage
        print(to_print,1,1+i*9,7)
        prof.this_frame = false
        i = i+1
    end
    profiles = {}
end

local function display_both()
    draw_cpu()
    display_profiles()
end

-- This swaps out function calls depending on whether or not you want to have
-- profiling. This is to make it as much as possible so that you don't have to
-- think about cleaning up profile calls for efficiency.
-- The first boolean is for detailed profiling, the second is for CPU usage.
function profile.enabled(detailed,cpu)
    profile_meta.__call = detailed and _profile or do_nothing
    profile.draw = detailed and (cpu and display_both or display_profiles)
        or (cpu and draw_cpu or do_nothing)
end