class Dry::CLI

def self.command?(command)
  case command
  when Class
    command.ancestors.include?(Command)
  else
    command.is_a?(Command)
  end
end

def anonymous_registry(&block)
  registry = Module.new { extend(Dry::CLI::Registry) }
  if block.arity.zero?
    registry.instance_eval(&block)
  else
    yield(registry)
  end
  registry
end

def build_command(command)
  command.is_a?(Class) ? command.new : command
end

def call(arguments: ARGV, out: $stdout, err: $stderr)
  @out, @err = out, err
  kommand ? perform_command(arguments) : perform_registry(arguments)
rescue SignalException => exception
  signal_exception(exception)
rescue Errno::EPIPE
  # no op
end

def command?(command)
  CLI.command?(command)
end

def error(result)
  err.puts(result.error)
  exit(1)
end

def help(command, prog_name)
  out.puts Banner.call(command, prog_name)
  exit(0) # Successful exit
end

def initialize(command_or_registry = nil, &block)
  @kommand = command_or_registry if command?(command_or_registry)
  @registry =
    if block_given?
      anonymous_registry(&block)
    else
      command_or_registry
    end
end

def parse(command, arguments, names)
  prog_name = ProgramName.call(names)
  result = Parser.call(command, arguments, prog_name)
  return help(command, prog_name) if result.help?
  return error(result) if result.error?
  [build_command(command), result.arguments]
end

def perform_command(arguments)
  command, args = parse(kommand, arguments, [])
  command.instance_variable_set(:@err, err) unless command.instance_variable_defined?(:@err)
  command.instance_variable_set(:@out, out) unless command.instance_variable_defined?(:@out)
  command.call(**args)
end

def perform_registry(arguments)
  result = registry.get(arguments)
  return spell_checker(result, arguments) unless result.found?
  command, args = parse(result.command, result.arguments, result.names)
  command.instance_variable_set(:@err, err) unless command.instance_variable_defined?(:@err)
  command.instance_variable_set(:@out, out) unless command.instance_variable_defined?(:@out)
  result.before_callbacks.run(command, **args)
  command.call(**args)
  result.after_callbacks.run(command, **args)
end

def signal_exception(exception)
  exit(128 + exception.signo)
end

def spell_checker(result, arguments)
  spell_checker = SpellChecker.call(result, arguments)
  err.puts spell_checker if spell_checker
  puts
  err.puts Usage.call(result)
  exit(1)
end