path: root/lua/clever_f/acquisition_service.lua

local domain = require("clever_f.domain")
local direct_preview_planner = require("clever_f.direct_preview_planner")
local feedback_service = require("clever_f.feedback_service")
local policy = require("clever_f.policy")
local sequence_state = require("clever_f.sequence_state")
local state_transitions = require("clever_f.state_transitions")
local text_topology = require("clever_f.text_topology")

local M = {}
local AcquisitionRequest = {}
local AcquisitionResult = {}
local AcquisitionService = {}
local TemporaryResourceScope = {}
AcquisitionService.__index = AcquisitionService
M.AcquisitionRequest = AcquisitionRequest
M.AcquisitionResult = AcquisitionResult
M.AcquisitionService = AcquisitionService
M.TemporaryResourceScope = TemporaryResourceScope
M.RepeatedDirection = {
  SAME = "same",
}
M.PROMPT = "clever-f: "

local request_records = setmetatable({}, { __mode = "k" })
local result_records = setmetatable({}, { __mode = "k" })
local service_records = setmetatable({}, { __mode = "k" })
local scope_records = setmetatable({}, { __mode = "k" })

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

local function normalize_macro_state(value)
  if type(value) == "table" and not domain.MacroState.is(value) then
    value = value.register
  end
  return domain.MacroState.new(value)
end

local request_metatable = {
  __index = function(request, key)
    local method = AcquisitionRequest[key]
    if method ~= nil then
      return method
    end
    return request_records[request][key]
  end,
  __newindex = function()
    fail("AcquisitionRequest values are immutable", 2)
  end,
  __tostring = function(request)
    return "acquisition-request:" .. request_records[request].descriptor.value
  end,
  __metatable = "clever_f.acquisition_service.AcquisitionRequest",
}

function AcquisitionRequest.new(descriptor, context, position, count, macro_state)
  if AcquisitionRequest.is(descriptor) then
    return descriptor
  end
  if type(descriptor) == "table" and not domain.Descriptor.is(descriptor) then
    local options = descriptor
    descriptor = options.descriptor
    context = options.context
    position = options.position or options.origin
    count = options.count
    macro_state = options.macro_state
  end

  local request = setmetatable({}, request_metatable)
  request_records[request] = {
    descriptor = domain.Descriptor.from_string(descriptor),
    context = domain.ModeContext.from_full_mode(context),
    position = domain.Position.coerce(position),
    count = domain.Count.new(count),
    macro_state = normalize_macro_state(macro_state),
    repeated_direction = M.RepeatedDirection.SAME,
  }
  return request
end

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

function AcquisitionRequest:to_table()
  return {
    descriptor = self.descriptor.value,
    context = self.context.key,
    position = self.position:to_table(),
    count = self.count.value,
    macro_register = self.macro_state.register,
    repeated_direction = self.repeated_direction,
  }
end

local result_metatable = {
  __index = function(result, key)
    local method = AcquisitionResult[key]
    if method ~= nil then
      return method
    end
    return result_records[result][key]
  end,
  __newindex = function()
    fail("AcquisitionResult values are immutable", 2)
  end,
  __tostring = function(result)
    local outcome = result_records[result].outcome
    return outcome and tostring(outcome) or "acquisition:resolved"
  end,
  __metatable = "clever_f.acquisition_service.AcquisitionResult",
}

function AcquisitionResult.new(request, options)
  if AcquisitionResult.is(request) and options == nil then
    return request
  end
  if not AcquisitionRequest.is(request) then
    fail("acquisition result requires an AcquisitionRequest", 2)
  end
  options = options or {}
  if type(options) ~= "table" then
    fail("acquisition result options must be a table", 2)
  end
  local outcome = options.outcome
  if outcome ~= nil and not domain.ActionOutcome.is(outcome) then
    fail("acquisition result outcome must be an ActionOutcome", 2)
  end
  local target = options.target
  if target ~= nil and not domain.TargetValue.is(target) then
    fail("acquisition result target must be a TargetValue", 2)
  end
  local result = setmetatable({}, result_metatable)
  result_records[result] = {
    request = request,
    outcome = outcome,
    target = target,
    target_plan = options.target_plan,
    motion_plan = options.motion_plan,
    resolved_motion_plan = options.motion_plan,
    previous_input_trigger = options.previous_input_trigger,
    previous_target_source = options.previous_target_source,
    cached_target = options.cached_target,
    completed = outcome ~= nil or target ~= nil,
  }
  return result
end

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

function AcquisitionResult:has_outcome()
  return self.outcome ~= nil
end

local scope_metatable = {
  __index = function(scope, key)
    local method = TemporaryResourceScope[key]
    if method ~= nil then
      return method
    end
    return scope_records[scope][key]
  end,
  __newindex = function()
    fail("TemporaryResourceScope values are read-only", 2)
  end,
  __metatable = "clever_f.acquisition_service.TemporaryResourceScope",
}

function TemporaryResourceScope.new(request, feedback)
  if not AcquisitionRequest.is(request) then
    fail("temporary resource scope requires an AcquisitionRequest", 2)
  end
  local scope = setmetatable({}, scope_metatable)
  scope_records[scope] = {
    request = request,
    feedback = feedback,
    active = true,
    cursor_marker = nil,
    direct_marker = nil,
    cursor_presentation_lease = nil,
    input_packet = nil,
    acquired_target = nil,
    resolved_target = nil,
    previous_input_trigger = nil,
    previous_target_source = nil,
    cached_target = nil,
    outcome = nil,
  }
  return scope
end

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

local function set_scope_resource(scope, field, resource)
  local record = scope_records[scope]
  if record == nil or not record.active then
    fail("temporary resource scope must be active", 3)
  end
  record[field] = resource
  return resource
end

function TemporaryResourceScope:set_cursor_marker(marker)
  return set_scope_resource(self, "cursor_marker", marker)
end

function TemporaryResourceScope:set_direct_marker(marker)
  return set_scope_resource(self, "direct_marker", marker)
end

function TemporaryResourceScope:set_cursor_presentation_lease(lease)
  return set_scope_resource(self, "cursor_presentation_lease", lease)
end

function TemporaryResourceScope:set_input_packet(packet)
  return set_scope_resource(self, "input_packet", packet)
end

function TemporaryResourceScope:set_acquired_target(target)
  return set_scope_resource(self, "acquired_target", target)
end

function TemporaryResourceScope:set_resolved_target(target)
  return set_scope_resource(self, "resolved_target", target)
end

function TemporaryResourceScope:set_previous_input_trigger(trigger)
  return set_scope_resource(self, "previous_input_trigger", trigger)
end

function TemporaryResourceScope:set_cached_target(context, target)
  set_scope_resource(self, "previous_target_source", context)
  return set_scope_resource(self, "cached_target", target)
end

function TemporaryResourceScope:set_outcome(outcome)
  if not domain.ActionOutcome.is(outcome) then
    fail("temporary resource scope outcome must be an ActionOutcome", 2)
  end
  return set_scope_resource(self, "outcome", outcome)
end

function TemporaryResourceScope:release()
  local record = scope_records[self]
  if record == nil then
    fail("temporary resource scope is invalid", 2)
  end
  record.active = false
end

local function require_policy(service, host)
  service = service or policy.new(host)
  if type(service) ~= "table" or type(service.sample_acquisition) ~= "function" then
    fail("AcquisitionService policy must sample acquisition settings", 3)
  end
  return service
end

local function require_state(state)
  state = state or sequence_state.get()
  if not sequence_state.is(state) then
    fail("AcquisitionService state must be the plugin-global SequenceState", 3)
  end
  return state
end

local function require_transitions(transitions, state)
  transitions = transitions or state_transitions.new(state)
  if type(transitions) ~= "table" or type(transitions.BeginAcquisition) ~= "function" then
    fail("AcquisitionService transitions must begin acquisition", 3)
  end
  return transitions
end

local function require_direct_planner(planner)
  planner = planner or direct_preview_planner.new()
  if type(planner) ~= "table" or type(planner.plan) ~= "function" then
    fail("AcquisitionService direct planner must provide plan", 3)
  end
  return planner
end

local function require_feedback(feedback, host, policy_service, transitions)
  feedback = feedback or feedback_service.new({
    host = host,
    policy = policy_service,
    transitions = transitions,
  })
  if type(feedback) ~= "table" or type(feedback.create_cursor_marker) ~= "function" then
    fail("AcquisitionService feedback must create cursor markers", 3)
  end
  return feedback
end

local function normalize_options(options, dependencies)
  if AcquisitionService.is(options) and dependencies == nil then
    return options
  end
  if type(options) ~= "table" then
    fail("AcquisitionService options must be a table", 3)
  end
  if options.host ~= nil then
    if dependencies ~= nil then
      fail("AcquisitionService dependencies must be part of its options", 3)
    end
    return options
  end
  local result = {}
  for key, value in pairs(dependencies or {}) do
    result[key] = value
  end
  result.host = options
  return result
end

function AcquisitionService.new(options, dependencies)
  options = normalize_options(options, dependencies)
  if AcquisitionService.is(options) then
    return options
  end
  if type(options.host) ~= "table" then
    fail("AcquisitionService host must be a table", 2)
  end
  local state = require_state(options.state)
  local transitions = require_transitions(
    options.transitions or options.state_transitions,
    state
  )
  local policy_service = require_policy(
    options.policy or options.policy_service,
    options.host
  )
  local service = setmetatable({}, AcquisitionService)
  service_records[service] = {
    host = options.host,
    policy = policy_service,
    state = state,
    transitions = transitions,
    feedback = require_feedback(
      options.feedback or options.feedback_service,
      options.host,
      policy_service,
      transitions
    ),
    direct_planner = require_direct_planner(
      options.direct_planner or options.direct_preview_planner
    ),
    window = options.window or options.current_window,
    last_scope = nil,
    started_scope_count = 0,
  }
  return service
end

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

function AcquisitionService:request(descriptor, context, position, count, macro_state)
  return AcquisitionRequest.new(descriptor, context, position, count, macro_state)
end

local function current_window(record)
  local window = record.window
  if type(window) == "function" then
    window = window()
  end
  if window == nil and type(record.host.read_window) == "function" then
    window = record.host:read_window()
  end
  if window == nil then
    fail("AcquisitionService requires a current window identity", 3)
  end
  return window
end

function AcquisitionService:start_temporary_scope(request)
  request = AcquisitionRequest.new(request)
  local record = service_records[self]
  local scope = TemporaryResourceScope.new(request, record.feedback)
  record.last_scope = scope
  record.started_scope_count = record.started_scope_count + 1
  return scope
end

function AcquisitionService:last_temporary_scope()
  return service_records[self].last_scope
end

function AcquisitionService:started_scope_count()
  return service_records[self].started_scope_count
end

local function utf8_first_code(character)
  local first = string.byte(character, 1)
  if first < 0x80 then
    return first
  end
  local length
  local code
  if first >= 0xc2 and first <= 0xdf then
    length = 2
    code = first - 0xc0
  elseif first >= 0xe0 and first <= 0xef then
    length = 3
    code = first - 0xe0
  elseif first >= 0xf0 and first <= 0xf4 then
    length = 4
    code = first - 0xf0
  else
    fail("ordinary input must start with a valid editor character", 3)
  end
  for index = 2, length do
    local byte = string.byte(character, index)
    if byte == nil or byte < 0x80 or byte > 0xbf then
      fail("ordinary input must contain a complete editor character", 3)
    end
    code = code * 0x40 + byte - 0x80
  end
  return code
end

local function first_editor_character(text)
  local characters = text_topology.split_editor_characters(text)
  if #characters == 0 then
    fail("ordinary input must contain an editor character", 3)
  end
  return characters[1]
end

function M.editor_character_code(character)
  character = first_editor_character(character)
  local runtime = rawget(_G, "vim")
  if type(runtime) == "table"
    and type(runtime.fn) == "table"
    and type(runtime.fn.char2nr) == "function"
  then
    return runtime.fn.char2nr(character)
  end
  return utf8_first_code(character)
end

function M.normalize_ordinary_input(packet)
  packet = domain.InputPacket.from_table(packet)
  local text
  if packet.kind == domain.InputPacketKind.TEXT then
    text = packet.text
  elseif packet.kind == domain.InputPacketKind.RAW_BYTES then
    local bytes = packet:bytes()
    local characters = {}
    for index = 1, #bytes do
      characters[index] = string.char(bytes[index])
    end
    text = table.concat(characters)
  else
    fail("ordinary input packet must contain text or raw bytes", 2)
  end
  local character = first_editor_character(text)
  return domain.TargetValue.character(
    character,
    M.editor_character_code(character)
  )
end

local function encoded_packet_value(packet)
  if packet.encoded ~= nil then
    return packet.encoded
  end
  local bytes = packet:bytes()
  if bytes == nil then
    return nil
  end
  local characters = {}
  for index = 1, #bytes do
    characters[index] = string.char(bytes[index])
  end
  return table.concat(characters)
end

function M.normalize_input_packet(packet)
  packet = domain.InputPacket.from_table(packet)
  if packet.kind == domain.InputPacketKind.ERROR then
    fail(packet.message, 2)
  end
  if packet.kind == domain.InputPacketKind.TEXT then
    return M.normalize_ordinary_input(packet)
  end

  local encoded = encoded_packet_value(packet)
  if encoded == nil then
    return domain.TargetValue.code_fallback(0)
  end
  if string.byte(encoded, 1) == 0x80 then
    return domain.TargetValue.special_key(encoded, 0x80)
  end
  return M.normalize_ordinary_input(domain.InputPacket.text(encoded))
end

function M.read_previous_target(state)
  if not sequence_state.is(state) then
    fail("previous-input reuse requires SequenceState", 2)
  end
  local context = state.last_input_context
  if context == nil then
    return nil, nil
  end
  return state:get_previous_target(context), context
end

function M.match_previous_input_trigger(first_code, triggers)
  if type(first_code) ~= "number" or first_code < 0 then
    fail("acquired first code must be nonnegative", 2)
  end
  if type(triggers) ~= "table" then
    fail("previous-input triggers must be a list", 2)
  end
  for index, trigger in ipairs(triggers) do
    if type(trigger) ~= "string" then
      fail("previous-input triggers must contain strings", 2)
    end
    if trigger ~= "" and M.editor_character_code(trigger) == first_code then
      return trigger, index
    end
  end
  return nil
end

function M.is_escape(packet)
  packet = domain.InputPacket.from_table(packet)
  if packet.kind == domain.InputPacketKind.SPECIAL_KEY
    and (packet.name == "Escape" or packet.name == "Esc")
  then
    return true
  end
  if packet.kind == domain.InputPacketKind.TEXT then
    return packet.text == string.char(27)
  end
  local bytes = packet:bytes()
  return bytes ~= nil and #bytes == 1 and bytes[1] == 27
end

function M.is_terminal_artifact(packet)
  packet = domain.InputPacket.from_table(packet)
  if packet.kind ~= domain.InputPacketKind.RAW_BYTES then
    return false
  end
  local bytes = packet:bytes()
  return #bytes == 3
    and bytes[1] == 0x80
    and bytes[2] == 0xfd
    and bytes[3] == 0x60
end

local function read_input_packet(host)
  while true do
    local packet = domain.InputPacket.from_table(host:read_input())
    if not M.is_terminal_artifact(packet) then
      return packet
    end
  end
end

local function direct_preview_settings(policy_service)
  if type(policy_service.sample_direct_preview) == "function" then
    return policy_service:sample_direct_preview()
  end
  if type(policy_service.get_boolean) == "function" then
    return {
      ignore_case = policy_service:get_boolean("ignore_case"),
      smart_case = policy_service:get_boolean("smart_case"),
    }
  end
  fail("AcquisitionService policy must sample direct preview settings", 3)
end

function AcquisitionService:acquire(descriptor, context, position, count, macro_state)
  local request = self:request(descriptor, context, position, count, macro_state)
  local scope = self:start_temporary_scope(request)
  local record = service_records[self]
  local acquisition = record.policy:sample_acquisition()
  local interactive = not request.macro_state.executing
  scope:set_cursor_presentation_lease(
    record.feedback:create_cursor_presentation_lease(
      interactive and acquisition.hide_cursor_on_cmdline
    )
  )
  if acquisition.mark_cursor then
    scope:set_cursor_marker(record.feedback:create_cursor_marker(
      request.position,
      current_window(record)
    ))
    if not request.macro_state.executing then
      record.host:redraw("screen")
    end
  end
  if acquisition.mark_direct and not request.macro_state.executing then
    local view = text_topology.from_host(record.host)
    local positions = record.direct_planner:plan(
      view,
      request.position,
      request.descriptor,
      request.count,
      direct_preview_settings(record.policy)
    )
    local window = scope.cursor_marker
        and scope.cursor_marker.window
      or current_window(record)
    scope:set_direct_marker(record.feedback:create_direct_markers(
      positions,
      window
    ))
    record.host:redraw("screen")
  end
  if acquisition.show_prompt and not request.macro_state.executing then
    record.host:show_prompt(M.PROMPT)
  end
  record.transitions:BeginAcquisition(request.context, request.descriptor)
  local packet = scope:set_input_packet(read_input_packet(record.host))
  if M.is_escape(packet) then
    local outcome = scope:set_outcome(domain.ActionOutcome.escape(request.position))
    scope:release()
    return AcquisitionResult.new(request, { outcome = outcome })
  end
  local target = scope:set_acquired_target(M.normalize_input_packet(packet))
  local previous_input = record.policy:sample_previous_input()
  local trigger = scope:set_previous_input_trigger(
    M.match_previous_input_trigger(
      target.first_code,
      previous_input.repeat_last_char_inputs
    )
  )
  if trigger ~= nil then
    local cached_target, source = M.read_previous_target(record.state)
    scope:set_cached_target(source, cached_target)
    if cached_target ~= nil then
      target = cached_target
    end
  end
  scope:set_resolved_target(target)
  return AcquisitionResult.new(request, {
    target = target,
    previous_input_trigger = trigger,
    previous_target_source = scope.previous_target_source,
    cached_target = scope.cached_target,
  })
end

function M.new(options, dependencies)
  return AcquisitionService.new(options, dependencies)
end

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

return M