local composition_root = require("clever_f.composition_root")
local host_adapter = require("clever_f.host_adapter")

local M = {}
local active_root
local active_activation

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

local function build_root(options)
  if composition_root.CompositionRoot.is(options) then
    return options
  end
  if host_adapter.HostAdapter.is(options) then
    return composition_root.new({ host = options })
  end
  options = options or {}
  if type(options) ~= "table" then
    fail("clever-f activation options must be a table", 3)
  end
  if options.host == nil then
    local adapter_options = options.runtime ~= nil
        and { runtime = options.runtime }
      or nil
    options = { host = host_adapter.new(adapter_options) }
  end
  return composition_root.new(options)
end

function M.activate(options)
  if active_root == nil then
    active_root = build_root(options)
    active_activation = active_root:activate()
  end
  return active_activation
end

local function root()
  M.activate()
  return active_root
end

function M.root()
  return root()
end

function M.state()
  return root():state()
end

local function invoke(name)
  local instance = root()
  return instance:host():invoke_action(name)
end

function M.StartFindForward()
  return invoke("StartFindForward")
end

function M.StartFindBackward()
  return invoke("StartFindBackward")
end

function M.StartTillForward()
  return invoke("StartTillForward")
end

function M.StartTillBackward()
  return invoke("StartTillBackward")
end

function M.Reset()
  return invoke("Reset")
end

function M.RepeatSameDirection()
  return invoke("RepeatSameDirection")
end

function M.RepeatOppositeDirection()
  return invoke("RepeatOppositeDirection")
end

local function invoke_direct(callback)
  local instance = root()
  local host = instance:host()
  if type(host.invoke_callback) ~= "function" then
    fail("clever-f host must invoke direct action callbacks", 2)
  end
  return host:invoke_callback(function()
    return callback(instance)
  end)
end

function M.invoke_descriptor(value)
  return invoke_direct(function(instance)
    return instance:invoke_descriptor(value)
  end)
end

function M._diagnostic_full_reset()
  return invoke_direct(function(instance)
    return instance:diagnostic_full_reset()
  end)
end

M.start_find_forward = M.StartFindForward
M.start_find_backward = M.StartFindBackward
M.start_till_forward = M.StartTillForward
M.start_till_backward = M.StartTillBackward
M.reset = M.Reset
M.repeat_same_direction = M.RepeatSameDirection
M.repeat_opposite_direction = M.RepeatOppositeDirection
M.free_form = M.invoke_descriptor

return M