class Jekyll::FrontmatterDefaults

def all(path, type)
  defaults = {}
  old_scope = nil
  matching_sets(path, type).each do |set|
    if has_precedence?(old_scope, set["scope"])
      defaults = Utils.deep_merge_hashes(defaults, set["values"])
      old_scope = set["scope"]
    else
      defaults = Utils.deep_merge_hashes(set["values"], defaults)
    end
  end
  defaults
end

def applies?(scope, path, type)
  applies_type?(scope, type) && applies_path?(scope, path)
end

def applies_path?(scope, path)
  rel_scope_path = scope["path"]
  return true if !rel_scope_path.is_a?(String) || rel_scope_path.empty?
  sanitized_path = sanitize_path(path)
  if rel_scope_path.include?("*")
    glob_scope(sanitized_path, rel_scope_path)
  else
    path_is_subpath?(sanitized_path, strip_collections_dir(rel_scope_path))
  end
end

def applies_type?(scope, type)
  !scope.key?("type") || type&.to_sym.eql?(scope["type"].to_sym)
end

def ensure_time!(set)
  return set unless set.key?("values") && set["values"].key?("date")
  return set if set["values"]["date"].is_a?(Time)
  set["values"]["date"] = Utils.parse_date(
    set["values"]["date"],
    "An invalid date format was found in a front-matter default set: #{set}"
  )
  set
end

def find(path, type, setting)
  value = nil
  old_scope = nil
  matching_sets(path, type).each do |set|
    if set["values"].key?(setting) && has_precedence?(old_scope, set["scope"])
      value = set["values"][setting]
      old_scope = set["scope"]
    end
  end
  value
end

def glob_cache(path)
  @glob_cache ||= {}
  @glob_cache[path] ||= Dir.glob(path)
end

def glob_scope(sanitized_path, rel_scope_path)
  site_source    = Pathname.new(@site.source)
  abs_scope_path = site_source.join(rel_scope_path).to_s
  glob_cache(abs_scope_path).each do |scope_path|
    scope_path = Pathname.new(scope_path).relative_path_from(site_source).to_s
    scope_path = strip_collections_dir(scope_path)
    Jekyll.logger.debug "Globbed Scope Path:", scope_path
    return true if path_is_subpath?(sanitized_path, scope_path)
  end
  false
end

def has_precedence?(old_scope, new_scope)
  return true if old_scope.nil?
  new_path = sanitize_path(new_scope["path"])
  old_path = sanitize_path(old_scope["path"])
  if new_path.length != old_path.length
    new_path.length >= old_path.length
  elsif new_scope.key?("type")
    true
  else
    !old_scope.key? "type"
  end
end

def initialize(site)
  @site = site
end

def matching_sets(path, type)
  @matched_set_cache ||= {}
  @matched_set_cache[path] ||= {}
  @matched_set_cache[path][type] ||= valid_sets.select do |set|
    !set.key?("scope") || applies?(set["scope"], path, type)
  end
end

def path_is_subpath?(path, parent_path)
  path.start_with?(parent_path)
end

def reset
  @glob_cache = {} if @glob_cache
end

def sanitize_path(path)
  if path.nil? || path.empty?
    ""
  elsif path.start_with?("/")
    path.gsub(%r!\A/|(?<=[^/])\z!, "")
  else
    path
  end
end

def strip_collections_dir(path)
  collections_dir  = @site.config["collections_dir"]
  slashed_coll_dir = collections_dir.empty? ? "/" : "#{collections_dir}/"
  return path if collections_dir.empty? || !path.to_s.start_with?(slashed_coll_dir)
  path.sub(slashed_coll_dir, "")
end

def update_deprecated_types(set)
  return set unless set.key?("scope") && set["scope"].key?("type")
  set["scope"]["type"] =
    case set["scope"]["type"]
    when "page"
      Deprecator.defaults_deprecate_type("page", "pages")
      "pages"
    when "post"
      Deprecator.defaults_deprecate_type("post", "posts")
      "posts"
    when "draft"
      Deprecator.defaults_deprecate_type("draft", "drafts")
      "drafts"
    else
      set["scope"]["type"]
    end
  set
end

def valid?(set)
  set.is_a?(Hash) && set["values"].is_a?(Hash)
end

def valid_sets
  sets = @site.config["defaults"]
  return [] unless sets.is_a?(Array)
  sets.map do |set|
    if valid?(set)
      ensure_time!(update_deprecated_types(set))
    else
      Jekyll.logger.warn "Defaults:", "An invalid front-matter default set was found:"
      Jekyll.logger.warn set.to_s
      nil
    end
  end.tap(&:compact!)
end