module SyntaxTree::CLI

# File lib/syntax_tree/cli.rb, line 599
def run(argv)
  name, *arguments = argv

  # First, we need to check if there's a --config option specified
  # so we can use the custom config file path.
  config_filepath = nil
  arguments.each_with_index do |arg, index|
    if arg.start_with?("--config=")
      config_filepath = arg.split("=", 2)[1]
      arguments.delete_at(index)
      break
    elsif arg == "--config" && arguments[index + 1]
      config_filepath = arguments[index + 1]
      arguments.delete_at(index + 1)
      arguments.delete_at(index)
      break
    end
  end

  config_file = ConfigFile.new(config_filepath)
  arguments = config_file.arguments.concat(arguments)

  options = Options.new
  options.parse(arguments)

  action =
    case name
    when "a", "ast"
      AST.new(options)
    when "c", "check"
      Check.new(options)
    when "ctags"
      CTags.new(options)
    when "debug"
      Debug.new(options)
    when "doc"
      Doc.new(options)
    when "e", "expr"
      Expr.new(options)
    when "f", "format"
      Format.new(options)
    when "help"
      puts HELP
      return 0
    when "j", "json"
      Json.new(options)
    when "lsp"
      LanguageServer.new(
        print_width: options.print_width,
        ignore_files: options.ignore_files
      ).run
      return 0
    when "m", "match"
      Match.new(options)
    when "s", "search"
      Search.new(arguments.shift)
    when "version"
      puts SyntaxTree::VERSION
      return 0
    when "w", "write"
      Write.new(options)
    else
      warn(HELP)
      return 1
    end

  # We're going to build up a queue of items to process.
  queue = Queue.new

  # If there are any arguments or scripts, then we'll add those to the
  # queue. Otherwise we'll read the content off STDIN.
  if arguments.any? || options.scripts.any?
    arguments.each do |pattern|
      Dir
        .glob(pattern)
        .each do |filepath|
          # Skip past invalid filepaths by default.
          next unless File.readable?(filepath)

          # Skip past any ignored filepaths.
          next if options.ignore_files.any? { File.fnmatch(_1, filepath) }

          # Otherwise, a new file item for the given filepath to the list.
          queue << FileItem.new(filepath)
        end
    end

    options.scripts.each do |script|
      queue << ScriptItem.new(script, options.extension)
    end
  else
    queue << STDINItem.new(options.extension)
  end

  # At the end, we're going to return whether or not this worker ever
  # encountered an error.
  if process_queue(queue, action)
    action.failure
    1
  else
    action.success
    0
  end
end