path: root/lua/clever_f/repeat_resolver.lua

local domain = require("clever_f.domain")
local sequence_state = require("clever_f.sequence_state")
local state_transitions = require("clever_f.state_transitions")

local M = {}
local RepeatResolver = {}
M.RepeatResolver = RepeatResolver

M.Decision = {
  ACQUIRE = "acquire",
  REPEAT = "repeat",
}
M.ACQUIRE = M.Decision.ACQUIRE
M.REPEAT = M.Decision.REPEAT

local resolver_records = setmetatable({}, { __mode = "k" })

local function fail(message, level)
  error(message, (level or 1) + 1)
end

local function is_nonnegative_integer(value)
  return type(value) == "number"
    and value >= 0
    and value < math.huge
    and value == math.floor(value)
end

local function require_policy(service)
  if service ~= nil and (type(service) ~= "table"
      or type(service.sample_timeouts) ~= "function")
  then
    fail("RepeatResolver policy must provide sample_timeouts", 3)
  end
  return service
end

local function require_clock(clock)
  if clock ~= nil and (type(clock) ~= "table"
      or type(clock.read_time_ms) ~= "function")
  then
    fail("RepeatResolver clock must provide read_time_ms", 3)
  end
  return clock
end

local function require_transitions(transitions, state)
  transitions = transitions or state_transitions.new(state)
  if type(transitions) ~= "table"
    or type(transitions.SetRepeatTimestamp) ~= "function"
  then
    fail("RepeatResolver transitions must set repeat timestamp", 3)
  end
  return transitions
end

local function finite_time(value)
  return type(value) == "number"
    and value == value
    and value > -math.huge
    and value < math.huge
end

function M.truncate_elapsed_ms(elapsed_ms)
  if not finite_time(elapsed_ms) then
    fail("elapsed milliseconds must be finite", 2)
  end
  local integer_part = math.modf(elapsed_ms)
  return integer_part
end

M.truncate_milliseconds = M.truncate_elapsed_ms

local resolver_metatable = {
  __index = RepeatResolver,
  __newindex = function()
    fail("RepeatResolver values are immutable", 2)
  end,
  __tostring = function()
    return "repeat-resolver"
  end,
  __metatable = "clever_f.repeat_resolver.RepeatResolver",
}

function RepeatResolver.new(options)
  if RepeatResolver.is(options) then
    return options
  end
  if options == nil then
    options = {}
  elseif sequence_state.is(options) then
    options = { state = options }
  elseif type(options) ~= "table" then
    fail("RepeatResolver options must be a table", 2)
  end

  local state = options.state or sequence_state.get()
  if not sequence_state.is(state) then
    fail("RepeatResolver state must be the plugin-global SequenceState", 2)
  end

  local resolver = setmetatable({}, resolver_metatable)
  resolver_records[resolver] = {
    clock = require_clock(options.clock or options.time_provider or options.host),
    policy = require_policy(options.policy or options.policy_service),
    state = state,
    transitions = require_transitions(
      options.transitions or options.state_transitions,
      state
    ),
  }
  return resolver
end

function RepeatResolver.is(value)
  return type(value) == "table" and resolver_records[value] ~= nil
end

function RepeatResolver:previous_landing(context)
  context = domain.ModeContext.from_full_mode(context)
  return resolver_records[self].state:get_previous_landing(context)
end

function RepeatResolver:decide(context, current_position, macro_state)
  current_position = domain.Position.coerce(current_position)
  local landing = self:previous_landing(context)
  if landing == nil or not domain.Position.equal(landing, current_position) then
    return M.Decision.ACQUIRE
  end
  if domain.MacroState.new(macro_state).executing then
    return M.Decision.ACQUIRE
  end
  return M.Decision.REPEAT
end

RepeatResolver.eligibility = RepeatResolver.decide
RepeatResolver.resolve_eligibility = RepeatResolver.decide

function RepeatResolver:sample_repeat_timeout_ms()
  local service = resolver_records[self].policy
  if service == nil then
    fail("RepeatResolver requires a policy to sample repeat timeout", 2)
  end
  local sampled = service:sample_timeouts()
  local timeout = type(sampled) == "table" and sampled.repeat_timeout_ms or nil
  if not is_nonnegative_integer(timeout) then
    fail("repeat_timeout_ms sample must be a nonnegative integer", 2)
  end
  return timeout
end

RepeatResolver.sample_repeat_timeout = RepeatResolver.sample_repeat_timeout_ms

function RepeatResolver:evaluate_timeout()
  local timeout = self:sample_repeat_timeout_ms()
  if timeout == 0 then
    return M.Decision.REPEAT, nil
  end

  local clock = resolver_records[self].clock
  if clock == nil then
    fail("RepeatResolver requires a clock for positive repeat timeout", 2)
  end
  local current_time = clock:read_time_ms()
  if not finite_time(current_time) then
    fail("repeat clock must return finite milliseconds", 2)
  end
  local record = resolver_records[self]
  local elapsed_ms = M.truncate_elapsed_ms(
    current_time - record.state.repeat_timestamp_ms
  )
  record.transitions:SetRepeatTimestamp(current_time)
  if elapsed_ms <= timeout then
    return M.Decision.REPEAT, elapsed_ms
  end
  return nil, elapsed_ms
end

RepeatResolver.check_timeout = RepeatResolver.evaluate_timeout
RepeatResolver.resolve_timeout = RepeatResolver.evaluate_timeout

function M.new(options)
  return RepeatResolver.new(options)
end

M.landing = function(context, options)
  return RepeatResolver.new(options):previous_landing(context)
end

function M.decide(context, current_position, macro_state, options)
  return RepeatResolver.new(options):decide(
    context,
    current_position,
    macro_state
  )
end

M.eligibility = M.decide

function M.sample_repeat_timeout_ms(options)
  return RepeatResolver.new(options):sample_repeat_timeout_ms()
end

function M.evaluate_timeout(options)
  return RepeatResolver.new(options):evaluate_timeout()
end

setmetatable(M, {
  __call = function(_, options)
    return RepeatResolver.new(options)
  end,
})

return M