class Jekyll::Configuration

def add_default_collections
  config = clone
  # It defaults to `{}`, so this is only if someone sets it to null manually.
  return config if config["collections"].nil?
  # Ensure we have a hash.
  if config["collections"].is_a?(Array)
    config["collections"] = config["collections"].each_with_object({}) do |collection, hash|
      hash[collection] = {}
    end
  end
  config["collections"] = Utils.deep_merge_hashes(
    { "posts" => {} }, config["collections"]
  ).tap do |collections|
    collections["posts"]["output"] = true
    if config["permalink"]
      collections["posts"]["permalink"] ||= style_to_permalink(config["permalink"])
    end
  end
  config
end

def add_default_excludes
  config = clone
  return config if config["exclude"].nil?
  config["exclude"].concat(DEFAULT_EXCLUDES).uniq!
  config
end

def check_include_exclude(config)
  %w(include exclude).each do |option|
    next unless config.key?(option)
    next if config[option].is_a?(Array)
    raise Jekyll::Errors::InvalidConfigurationError,
          "'#{option}' should be set as an array, but was: #{config[option].inspect}."
  end
end

def check_plugins(config)
  return unless config.key?("plugins")
  return if config["plugins"].is_a?(Array)
  Jekyll.logger.error "'plugins' should be set as an array of gem-names, but was: " \
                      "#{config["plugins"].inspect}. Use 'plugins_dir' instead to set " \
                      "the directory for your non-gemified Ruby plugins."
  raise Jekyll::Errors::InvalidConfigurationError,
        "'plugins' should be set as an array, but was: #{config["plugins"].inspect}."
end

def config_files(override)
  # Adjust verbosity quickly
  Jekyll.logger.adjust_verbosity(
    :quiet   => quiet?(override),
    :verbose => verbose?(override)
  )
  # Get configuration from <source>/_config.yml or <source>/<config_file>
  config_files = override["config"]
  if config_files.to_s.empty?
    default = %w(yml yaml toml).find(-> { "yml" }) do |ext|
      File.exist?(Jekyll.sanitized_path(source(override), "_config.#{ext}"))
    end
    config_files = Jekyll.sanitized_path(source(override), "_config.#{default}")
    @default_config_file = true
  end
  Array(config_files)
end

def csv_to_array(csv)
  csv.split(",").map(&:strip)
end

def from(user_config)
  Utils.deep_merge_hashes(DEFAULTS, Configuration[user_config].stringify_keys)
    .add_default_collections.add_default_excludes
end

def get_config_value_with_override(config_key, override)
  override[config_key] || self[config_key] || DEFAULTS[config_key]
end

def quiet(override = {})
  get_config_value_with_override("quiet", override)
end

def read_config_file(file)
  file = File.expand_path(file)
  next_config = safe_load_file(file)
  unless next_config.is_a?(Hash)
    raise ArgumentError, "Configuration file: (INVALID) #{file}".yellow
  end
  Jekyll.logger.info "Configuration file:", file
  next_config
rescue SystemCallError
  if @default_config_file ||= nil
    Jekyll.logger.warn "Configuration file:", "none"
    {}
  else
    Jekyll.logger.error "Fatal:", "The configuration file '#{file}' could not be found."
    raise LoadError, "The Configuration file '#{file}' could not be found."
  end
end

def read_config_files(files)
  configuration = clone
  begin
    files.each do |config_file|
      next if config_file.nil? || config_file.empty?
      new_config = read_config_file(config_file)
      configuration = Utils.deep_merge_hashes(configuration, new_config)
    end
  rescue ArgumentError => e
    Jekyll.logger.warn "WARNING:", "Error reading configuration. Using defaults (and options)."
    warn e
  end
  configuration.validate.add_default_collections
end

def safe_load_file(filename)
  case File.extname(filename)
  when %r!\.toml!i
    Jekyll::External.require_with_graceful_fail("tomlrb") unless defined?(Tomlrb)
    Tomlrb.load_file(filename)
  when %r!\.ya?ml!i
    SafeYAML.load_file(filename) || {}
  else
    raise ArgumentError,
          "No parser for '#{filename}' is available. Use a .y(a)ml or .toml file instead."
  end
end

def source(override)
  get_config_value_with_override("source", override)
end

def stringify_keys
  each_with_object({}) { |(k, v), hsh| hsh[k.to_s] = v }
end

def style_to_permalink(permalink_style)
  STYLE_TO_PERMALINK[permalink_style.to_sym] || permalink_style.to_s
end

def validate
  config = clone
  check_plugins(config)
  check_include_exclude(config)
  config
end

def verbose(override = {})
  get_config_value_with_override("verbose", override)
end