class YARD::Config

def self.add_ignored_plugins_file
  if File.file?(IGNORED_PLUGINS)
    options[:ignored_plugins] += File.read(IGNORED_PLUGINS).split(/\s+/)
  end
end

def self.arguments
  ARGV + @yardopts
end

def self.load
  self.options = SymbolHash.new(false)
  options.update(DEFAULT_CONFIG_OPTIONS)
  options.update(read_config_file)
  load_commandline_safemode
  add_ignored_plugins_file
  translate_plugin_names
  load_plugins
rescue => e
  log.error "Invalid configuration file, using default options."
  log.backtrace(e)
  options.update(DEFAULT_CONFIG_OPTIONS)
end

def self.load_autoload_plugins
  options[:autoload_plugins].each {|name| load_plugin(name) }
end

def self.load_commandline_plugins
  with_yardopts do
    arguments.each_with_index do |arg, i|
      next unless arg == '--plugin'
      load_plugin(arguments[i + 1])
    end
  end
end

def self.load_commandline_safemode
  with_yardopts do
    arguments.each_with_index do |arg, _i|
      options[:safe_mode] = true if arg == '--safe'
    end
  end
end

def self.load_gem_plugins
  return true unless options[:load_plugins]
  require 'rubygems'
  result = true
  YARD::GemIndex.each do |gem|
    begin
      next true unless gem.name =~ YARD_PLUGIN_PREFIX
      load_plugin(gem.name)
    rescue Gem::LoadError => e
      tmp = load_plugin_failed(gem.name, e)
      result = tmp unless tmp
    end
  end
  result
rescue LoadError
  log.debug "RubyGems is not present, skipping plugin loading"
  false
end

def self.load_plugin(name)
  name = translate_plugin_name(name)
  return false if options[:ignored_plugins].include?(name)
  return false if name =~ /^yard-doc-/
  log.debug "Loading plugin '#{name}'..."
  require name
  true
rescue LoadError => e
  load_plugin_failed(name, e)
end

def self.load_plugin_failed(name, exception)
  log.error "Error loading plugin '#{name}'"
  log.backtrace(exception) if $DEBUG
  false
end

def self.load_plugins
  load_gem_plugins &&
    load_autoload_plugins &&
    load_commandline_plugins ? true : false
end

def self.read_config_file
  if File.file?(CONFIG_FILE)
    require 'yaml'
    if YAML.respond_to?(:safe_load_file)
      YAML.safe_load_file(CONFIG_FILE, permitted_classes: [SymbolHash, Symbol])
    else
      YAML.load_file(CONFIG_FILE)
    end
  else
    {}
  end
end

def self.save
  require 'yaml'
  Dir.mkdir(CONFIG_DIR) unless File.directory?(CONFIG_DIR)
  File.open(CONFIG_FILE, 'w') {|f| f.write(YAML.dump(options)) }
end

def self.translate_plugin_name(name)
  name = name.delete('/') # Security sanitization
  name = "yard-" + name unless name =~ YARD_PLUGIN_PREFIX
  name
end

def self.translate_plugin_names
  options[:ignored_plugins].map! {|name| translate_plugin_name(name) }
  options[:autoload_plugins].map! {|name| translate_plugin_name(name) }
end

def self.with_yardopts
  yfile = CLI::Yardoc::DEFAULT_YARDOPTS_FILE
  @yardopts = File.file?(yfile) ? File.read_binary(yfile).shell_split : []
  result = yield
  @yardopts = nil
  result
end