utils.lua

require 'legacy_interface'

import 'System.Numerics'

-- if present load the character info
pcall(require, 'private/char_info')


SCRIPT_TAG = "[EriSND]"

-----------------------
-- General Utilities --
-----------------------

function default(value, default_value)
    if value == nil then return default_value end
    return value
end

function wait(duration)
    yield('/wait ' .. string.format("%.1f", duration))
end

function is_bit_set(value, bitIndex)
    local mask = 1 << bitIndex
    local value_num = tonumber(value)
    local masked = value_num & mask
    log_(LEVEL_VERBOSE, _text, "Checking bit", bitIndex, "in value", value_num, "with mask", mask, "result:",
        masked)
    return masked ~= 0
end

function __pause_request(pause, name)
    local set = get_shared_data(name, "System.Collections.Generic.HashSet`1[System.String]")
    if set == nil then
        return
    end
    if pause then
        set:Add(SCRIPT_TAG)
    else
        set:Remove(SCRIPT_TAG)
    end
end

__PAUSE_HANDLES = {
    "YesAlready.StopRequests",
    "TextAdvance.StopRequests",
}

function pause_pyes()
    pyes_pause_count = default(pyes_pause_count, 0)
    pyes_pause_count = pyes_pause_count + 1
    for _, option in pairs(__PAUSE_HANDLES) do
        __pause_request(true, option)
    end
end

function resume_pyes()
    if pyes_pause_count == nil then
        return
    end
    pyes_pause_count = pyes_pause_count - 1
    if pyes_pause_count == 0 then
        for _, option in pairs(__PAUSE_HANDLES) do
            __pause_request(false, option)
            release_shared_data(option)
        end
    end
end

function find_after(msg, target, after)
    e, s = msg:reverse():find(after:reverse())
    if e == nil then
        return nil -- cant find something after something if the second thing doesnt exist!
    end
    return string.find(msg, target, -e)
end

function get_chat_messages(tab)
    local chat = GetNodeText("ChatLogPanel_" .. tostring(tab), 1, 2, 3)
    if chat == 2 then
        StopScript("Error getting chat log")
    end
    return chat
end

function wait_message(after, timeout, ...)
    local ti = ResetTimeout()
    local messages = { ... }
    local found = false

    timeout = default(timeout, 10)
    repeat
        CheckTimeout(timeout, ti, CallerName(false), "Waiting for message '" .. after .. "' followed by", ...)
        wait(.1)
        for i = 1, #messages do
            if find_after(get_chat_messages(3), messages[i], after) then
                found = true
            end
        end
    until found
end

function open_addon(addon, base_addon, ...)
    wait_any_addons(base_addon)
    local ti = ResetTimeout()
    while not IsAddonReady(addon) do
        CheckTimeout(1, ti, CallerName(false), "Opening addon", addon)
        if not IsAddonReady(base_addon) then
            StopScript("open_addon failed", CallerName(false), "Failed opening", addon,
                "base addon missing or not ready",
                base_addon)
        end
        SafeCallback(base_addon, ...)
        wait(0.1)
    end
end

function confirm_addon(addon, ...)
    local ti = ResetTimeout()
    while IsAddonReady(addon) do
        CheckTimeout(1, ti, CallerName(false), "Confirming addon", addon)
        SafeCallback(addon, ...)
        wait(0.1)
    end
end

function talk(who, what_addon)
    what_addon = default(what_addon, "SelectString")
    local ti = ResetTimeout()
    repeat
        CheckTimeout(10, ti, CallerName(false), "Talking to", who, "to open addon", what_addon)
        local entity = get_closest_entity(who)
        entity:SetAsTarget()
        entity:Interact()
        wait(.5)
    until IsAddonReady(what_addon)
end

function close_yes_no(accept, expected_text)
    accept = default(accept, false)
    if IsAddonReady("SelectYesno") then
        if expected_text ~= nil then
            local node = GetNodeText("SelectYesno", 1, 2)
            if node == nil or not node:upper():find(expected_text:upper()) then
                log_(LEVEL_DEBUG, _text, "Expected yesno text '" .. expected_text .. "' didnt match actual text:", node)
                return
            end
        end
        if accept then
            SafeCallback("SelectYesno", true, 0)
        else
            SafeCallback("SelectYesno", true, 1)
        end
    end
end

function close_talk(first, ...)
    local ti = ResetTimeout()
    while (first ~= nil and not any_addons_ready(first, ...)) or (first == nil and GetCharacterCondition(32)) do
        yield("/click Talk Click")
        CheckTimeout(60, ti, CallerName(false), "Finishing talking")
        wait(.1)
    end
end

function close_addon(addon)
    local ti = ResetTimeout()
    while IsAddonReady(addon) do
        CheckTimeout(1, ti, CallerName(false), "Closing addon", addon)
        SafeCallback(addon, true, -1)
        wait(0)
    end
end

function any_addons_ready(...)
    target_addons = { ... }
    for _, v in pairs(target_addons) do
        if IsAddonReady(v) then
            return v
        end
    end
    return nil
end

function wait_any_addons(...)
    local ti = ResetTimeout()
    while true do
        ready = any_addons_ready(...)
        if ready ~= nil then
            return ready
        end
        CheckTimeout(30, ti, CallerName(false), "Waiting for addons", ...)
        wait(0.1)
    end
end

function open_retainer_bell()
    OpenShop("Summoning Bell", { "RetainerList", "SelectString", "RetainerGrid", "RetainerTaskAsk", "Bank" })
    if IPC.AutoRetainer.AreAnyRetainersAvailableForCurrentChara() then
        repeat
            wait(1)
        until not IPC.AutoRetainer.IsBusy()
    end
    wait_any_addons("RetainerList")
end

function title_case(str)
    local title = str:gsub("(%a)([%w']*)", function(first, rest) return first:upper() .. rest:lower() end)
    return title
end

function close_addons(addons)
    while is_busy() do
        wait(.1)
        for _, addon in pairs(addons) do
            close_addon(addon)
        end
    end
end

---------------------------------------------------------
-------- Character utils if char data was loaded --------
---------------------------------------------------------

function char_cannonical_name(char)
    if char == nil then
        return nil
    end
    if private_char_info == nil then
        return title_case(char)
    end
    char = char:upper()
    potential_char = {}
    for known_char, known_char_info in pairs(private_char_info) do
        known_char = known_char:upper()
        if known_char == char then
            return title_case(known_char)
        end
        if known_char:match("^" .. char .. " ") then
            return title_case(known_char)
        end
        if known_char_info.ReferenceNames ~= nil then
            for _, ref_name in pairs(known_char_info.ReferenceNames) do
                if ref_name:upper() == char then
                    return title_case(known_char)
                end
            end
        end
        if known_char:match(char) then
            table.insert(potential_char, known_char)
        end
    end
    if #potential_char == 1 then
        return title_case(potential_char[1])
    elseif #potential_char > 1 then
        log_(LEVEL_DEBUG, _text, "Ambiguous character name", char, "candidates:", table.concat(potential_char, ", "))
        return title_case(char)
    else
        log_(LEVEL_DEBUG, _text, "Unknown character name", char)
        return title_case(char)
    end
end

function get_char_info(char)
    if char == nil then
        return nil
    end
    if private_char_info == nil then
        return nil
    end
    char = char_cannonical_name(char)
    return private_char_info[char]
end

function char_homeworld(char)
    local char_info = get_char_info(char)
    if char_info == nil then
        return nil
    end
    return char_info.Homeworld
end

function change_character(char, world, max_time)
    max_time = default(max_time, 10 * 60)
    local ti = ResetTimeout()
    char = char_cannonical_name(char)
    world = title_case(default(world, char_homeworld(char)))

    local target = string.format("%s@%s", char, world)

    log_(LEVEL_DEBUG, _text, "Changing to character", target)

    if Player.Entity.Name == char and luminia_row_checked("World", Player.Entity.HomeWorld).Name == world then
        log_(LEVEL_DEBUG, _text, "Already on target character", target)
        return
    end

    running_lifestream = true
    IPC.Lifestream.ExecuteCommand(target)

    repeat
        CheckTimeout(max_time, ti, "ZoneTransition", "Waiting for lifestream to start")
        wait(.1)
    until IPC.Lifestream.IsBusy()

    repeat
        CheckTimeout(max_time, ti, "ZoneTransition", "Waiting for lifestream to finish")
        wait(10)
    until not IPC.Lifestream.IsBusy()
    log_(LEVEL_DEBUG, _text, "Lifestream done")

    repeat
        CheckTimeout(max_time, ti, "ZoneTransition", "Waiting for zone transition to end")
        wait(5)
    until IsPlayerAvailable()

    log_(LEVEL_DEBUG, _text, "relog done")
    wait_ready(max_time, 2)
    log_(LEVEL_DEBUG, _text, "Ready!")
end

function is_busy()
    return Player.IsBusy or GetCharacterCondition(6) or GetCharacterCondition(26) or GetCharacterCondition(27) or
        GetCharacterCondition(43) or
        GetCharacterCondition(45) or GetCharacterCondition(51) or GetCharacterCondition(32) or
        not (GetCharacterCondition(1) or GetCharacterCondition(4)) or
        (not IPC.vnavmesh.IsReady()) or IPC.vnavmesh.PathfindInProgress() or IPC.vnavmesh.IsRunning()
end

function wait_ready(max_wait, n_ready, stationary)
    stationary = default(stationary, true)
    n_ready = default(n_ready, 5)
    local ready_count = 0
    local ti = nil
    local p = Entity.Player.Position
    if max_wait ~= nil then
        ti = ResetTimeout()
    end
    repeat
        if ti ~= nil then
            CheckTimeout(max_wait, ti, CallerName(), "wait_ready timed out with ready count", ready_count, "and target",
                n_ready)
        end
        wait(1)
        if is_busy() or (stationary and Vector3.Distance(p, Entity.Player.Position) > 1) then
            p = Entity.Player.Position
            ready_count = 0
        else
            ready_count = ready_count + 1
        end
    until ready_count >= n_ready
end

function luminia_row_checked(table, id)
    local sheet = Excel.GetSheet(table)
    if sheet == nil then
        StopScript("Unknown sheet", CallerName(false), "sheet not found for", table)
    end
    local row = sheet:GetRow(id)
    if row == nil then
        StopScript("Unknown id", CallerName(false), "Id not found in excel data", table, id)
    end
    return row
end

function atk_data_checked(addon, index)
    local w = Addons.GetAddon(addon)
    if not (w.Exists and w.Ready) then
        StopScript("No addon", CallerName(false), "addon", addon, "not ready")
    end
    local r = w:GetAtkValue(index)
    if r == nil then
        StopScript("Bad atk index", CallerName(false), "addon", addon, "does not have index", index)
    end
    return r.ValueString
end

ListSelectionType = {
    ContextMenu = { name_offset = 6, click_offset = 0 },
    RetainerList = { name_offset = 3, click_offset = 2 },
    SelectString = { name_offset = 3 },
    SelectIconString = { name_offset = 3 },
}

-- 0 indexed
function list_index(base, index)
    if index == 0 then
        return base
    end
    return base * 10000 + 1000 + index
end

function GetListElement(menu, index)
    local a = Addons.GetAddon(menu)
    if not a.Ready then
        StopScript("Bad addon", CallerName(false), menu)
    end
    local n = nil
    if menu == "ContextMenu" then
        n = a:GetNode(1, 2, list_index(3, index), 2, 3)
    elseif menu == "RetainerList" then
        n = a:GetNode(1, 27, list_index(4, index), 2, 3)
    elseif menu == "SelectString" or menu == "SelectIconString" then
        n = a:GetNode(1, 3, list_index(5, index), 2)
    else
        StopScript("Unknown addon", CallerName(false), menu)
    end
    if tostring(n.NodeType):find("Text:") == nil then
        log_(LEVEL_DEBUG, _text, "Not a text node", CallerName(false), "NodeType:", n.NodeType, "NodeId:", n.Id, name,
            menu, index)
        return nil
    end
    return n.Text
end

function ListContents(menu)
    menu = default(menu, "ContextMenu")
    wait_any_addons(menu)
    local list_items = {}
    for i = 0, 21 do
        entry = GetListElement(menu, i)
        if entry == nil then break end
        if entry ~= "" then
            table.insert(list_items, entry)
        end
    end
    return list_items
end

function SelectInList(name, menu, partial_ok)
    partial_ok = default(partial_ok, false)
    local string = name
    local click
    menu = default(menu, "ContextMenu")
    local offsets = ListSelectionType[menu]
    ::Retry::
    wait_any_addons(menu)
    if string then
        for i = 0, 21 do
            local entry = GetListElement(menu, i)
            if entry == nil then break end
            log_(LEVEL_DEBUG, _text, "List item", entry)
            local match = entry:upper() == string:upper()
            if not match and partial_ok then
                match = entry:upper():find(string:upper())
            end
            if match then
                click = i
                break
            end
        end
        if click then
            if offsets.click_offset ~= nil then
                SafeCallback(menu, true, offsets.click_offset, click)
            else
                SafeCallback(menu, true, click)
            end
            if string == "Second Tier" then
                string = name
                click = nil
                menu = "AddonContextSub"
                yield("/wait 0.1")
                goto Retry
            end
        elseif string ~= "Second Tier" then
            string = "Second Tier"
            goto Retry
        end
    end
    if click then return true else return false end
end

function list_contains(table, element)
    if table == nil then
        -- A non-existant table does not contain anything
        -- This abstraction allows not initializing if there is no items in some uses
        return false
    end
    for _, value in pairs(table) do
        if value == element then
            return true
        end
    end
    return false
end

function table_keys(t)
    local keys = {}
    for k, _ in pairs(t) do
        table.insert(keys, k)
    end
    return keys
end

function list_concat(...)
    local result = {}
    local count = 0
    local lists = table.pack(...)
    for i = 1, lists.n do
        local list = lists[i]
        for j = 1, #list do
            result[count + j] = list[j]
        end
        count = count + #list
    end
    return result
end

function SafeCallback(addon, update, ...)
    pause_pyes()
    local callback_table = table.pack(...)
    if type(addon) ~= "string" then
        StopScript("addonname must be a string")
    end
    if type(update) == "boolean" then
        update = tostring(update)
    else
        StopScript("update must be a bool")
    end

    local call_command = "/callback " .. addon .. " " .. update
    for i = 1, callback_table.n do
        local value = callback_table[i]
        if type(value) == "number" then
            call_command = call_command .. " " .. tostring(value)
        elseif type(value) == "string" then
            call_command = call_command .. " \"" .. value .. "\""
        else
            StopScript("Callbacks have to use numbers or strings!")
        end
    end
    log_(LEVEL_DEBUG, _text, "Calling addon with command", call_command)
    if IsAddonReady(addon) then
        yield(call_command)
    end
    resume_pyes()
end

function bool_to_string(state, true_string, false_string)
    true_string = default(true_string, "true")
    false_string = default(false_string, "false")
    if type(state) == "boolean" then
        if state then
            return true_string
        else
            return false_string
        end
    else
        StopScript("state must be a bool")
    end
end

function string_to_bool(str, truey_values, falsey_values)
    str = str:lower()
    truey_values = default(truey_values, { "true", "on", "yes" })
    falsey_values = default(falsey_values, { "false", "off", "no" })

    for _, v in pairs(truey_values) do
        if str == v:lower() then
            return true
        end
    end

    for _, v in pairs(falsey_values) do
        if str == v:lower() then
            return false
        end
    end
    StopScript("InvalidBooleanString", CallerName(false), str)
end

--------------------
-- Error Handling --
--------------------

function require_plugins(plugins)
    if #plugins == 0 then
        return
    end
    for p in luanet.each(Svc.PluginInterface.InstalledPlugins) do
        for i, v in pairs(plugins) do
            if p.IsLoaded and p.InternalName == v then
                table.remove(plugins, i)
                if #plugins == 0 then
                    return
                end
                break
            end
        end
    end
    if #plugins > 0 then
        StopScript("Missing required plugins", CallerName(false), "Missing plugins:", table.concat(plugins, ", "))
    end
end

function StopScript(message, caller, ...)
    caller = default(caller, CallerName())
    log("Fatal error " .. message .. " in " .. caller .. ": ", ...)
    if default(running_questy, false) then
        yield("/qst stop")
    end
    if default(running_lifestream, false) then
        IPC.Lifestream.Abort()
    end
    if default(running_visland, false) then
        IPC.visland.StopRoute()
    end
    if default(running_vnavmesh, false) or default(running_visland, false) or default(running_lifestream, false) or default(running_questy, false) then
        IPC.vnavmesh.Stop()
    end
    if pyes_pause_count ~= nil and pyes_pause_count > 0 then
        for _, option in pairs(__PAUSE_HANDLES) do
            __pause_request(false, option)
        end
    end
    release_shared_data()
    luanet.error(_text(message, ...))
end

NO_CALL_INFO = true

function CallerName(string)
    if NO_CALL_INFO then
        return "(unknown caller)"
    end
    string = default(string, true)
    return debug_info_tostring(debug.getinfo(3), string)
end

function FunctionInfo(string)
    if NO_CALL_INFO then
        return "(unknown function)"
    end
    string = default(string, true)
    return debug_info_tostring(debug.getinfo(2), string)
end

function debug_info_tostring(debuginfo, always_string)
    string = default(string, true)
    local caller = debuginfo.name
    if caller == nil and not always_string then
        return nil
    end
    local file = debuginfo.short_src:gsub('.*\\', '') .. ":" .. debuginfo.currentline
    return tostring(caller) .. "(" .. file .. ")"
end

function caller_test()
    test2()
end

function test2()
    log(CallerName())
end

--------------------
--- Chat Logging ---
--------------------

LEVEL_VERBOSE = 9
LEVEL_DEBUG = 7
LEVEL_INFO = 5
LEVEL_ERROR = 3
LEVEL_CRITICAL = 1

debug_level = default(debug_level, LEVEL_ERROR)

function log_(level, formatter, ...)
    local msg = formatter(...)
    local msg_tagged = SCRIPT_TAG .. " " .. msg
    if LEVEL_INFO >= level then
        Dalamud.Log(msg_tagged)
    elseif LEVEL_DEBUG >= level then
        Dalamud.LogDebug(msg_tagged)
    elseif LEVEL_VERBOSE >= level then
        Dalamud.LogVerbose(msg_tagged)
    end
    if debug_level >= level then
        Svc.Chat:Print(msg)
    end
end

function _text(first, ...)
    local rest = table.pack(...)
    local message = tostring(first)
    for i = 1, rest.n do
        message = message .. ' ' .. tostring(rest[i])
    end
    return message
end

function log(...)
    log_(LEVEL_CRITICAL, _text, ...)
end

function _count(list, c, type)
    local msg = default(type, 'collection') .. ':'
    for i = 0, c - 1 do
        msg = msg .. '\n' .. tostring(i) .. ': ' .. tostring(list[i])
    end
    return msg
end

function _iterable(it)
    local msg = '---' .. tostring(it) .. '---'
    for i in luanet.each(it) do
        msg = msg .. '\n' .. tostring(i)
    end
    return msg .. '\n--- end ---'
end

function _list(list, header)
    local c = list.Count
    if c == nil then
        return "Not a list (No Count property): " .. tostring(list)
    else
        return _count(list, c, default(header, 'list'))
    end
end

function _array(array, header)
    local c = array.Length
    if c == nil then
        return "Not an array (No Length property): " .. tostring(array)
    else
        return _count(array, c, default(header, 'array'))
    end
end

function _table(list, header)
    local msg = default(header, 'table:')
    for i, v in pairs(list) do
        msg = msg .. '\n' .. tostring(i) .. ': ' .. tostring(v)
    end
    return msg
end

-----------------------
-- Timeout Functions --
-----------------------


function ResetTimeout()
    return os.clock()
end

function CheckTimeout(max_duration, wait_info, context, ...)
    if wait_info == nil then
        StopScript("wait_info is nil", CallerName(false), "Must be initialized with ResetTimeout()", "context:",
            default(context, CallerName(false)), ...)
    end
    if max_duration == nil then
        StopScript("max_duration is nil", CallerName(false), "Must be provided", "context:",
            default(context, CallerName(false)), ...)
    end
    if os.clock() > wait_info + max_duration then
        StopScript("Max duration reached", default(context, CallerName(false)), ...)
    end
end

function AlertTimeout(max_duration, wait_info, caller_name, ...)
    wait_info = default(wait_info, global_wait_info)
    if wait_info == global_wait_info and CallerName() ~= wait_info.current_timed_function then
        wait_info = ResetTimeout()
    end
    max_duration = default(max_duration, 30)
    if os.clock() > wait_info.current_timed_start + max_duration then
        log("Max duration reached", default(caller_name, CallerName(false)), ...)
        return true
    end
    return false
end