module Jekyll::Utils

def add_permalink_suffix(template, permalink_style)
  template = template.dup
  case permalink_style
  when :pretty
    template << "/"
  when :date, :ordinal, :none
    template << ":output_ext"
  else
    template << "/" if permalink_style.to_s.end_with?("/")
    template << ":output_ext" if permalink_style.to_s.end_with?(":output_ext")
  end
  template
end

def deep_merge_hashes(master_hash, other_hash)
  deep_merge_hashes!(master_hash.dup, other_hash)
end

def deep_merge_hashes!(target, overwrite)
  merge_values(target, overwrite)
  merge_default_proc(target, overwrite)
  duplicate_frozen_values(target)
  target
end

def duplicable?(obj)
  case obj
  when nil, false, true, Symbol, Numeric
    false
  else
    true
  end
end

def duplicate_frozen_values(target)
  target.each do |key, val|
    target[key] = val.dup if val.frozen? && duplicable?(val)
  end
end

def has_liquid_construct?(content)
  return false if content.nil? || content.empty?
  content.include?("{%") || content.include?("{{")
end

def has_yaml_header?(file)
  File.open(file, "rb", &:readline).match? %r!\A---\s*\r?\n!
rescue EOFError
  false
end

def mergable?(value)
  value.is_a?(Hash) || value.is_a?(Drops::Drop)
end

def merge_default_proc(target, overwrite)
  if target.is_a?(Hash) && overwrite.is_a?(Hash) && target.default_proc.nil?
    target.default_proc = overwrite.default_proc
  end
end

def merge_values(target, overwrite)
  target.merge!(overwrite) do |_key, old_val, new_val|
    if new_val.nil?
      old_val
    elsif mergable?(old_val) && mergable?(new_val)
      deep_merge_hashes(old_val, new_val)
    else
      new_val
    end
  end
end

def merged_file_read_opts(site, opts)
  merged = (site ? site.file_read_opts : {}).merge(opts)
  # always use BOM when reading UTF-encoded files
  if merged[:encoding]&.downcase&.start_with?("utf-")
    merged[:encoding] = "bom|#{merged[:encoding]}"
  end
  if merged["encoding"]&.downcase&.start_with?("utf-")
    merged["encoding"] = "bom|#{merged["encoding"]}"
  end
  merged
end

def parse_date(input, msg = "Input could not be parsed.")
  @parse_date_cache ||= {}
  @parse_date_cache[input] ||= Time.parse(input).localtime
rescue ArgumentError
  raise Errors::InvalidDateError, "Invalid date '#{input}': #{msg}"
end

def pluralized_array_from_hash(hash, singular_key, plural_key)
  array = []
  value = value_from_singular_key(hash, singular_key)
  value ||= value_from_plural_key(hash, plural_key)
  array << value
  array.flatten!
  array.compact!
  array
end

def replace_character_sequence_with_hyphen(string, mode: "default")
  replaceable_char =
    case mode
    when "raw"
      SLUGIFY_RAW_REGEXP
    when "pretty"
      # "._~!$&'()+,;=@" is human readable (not URI-escaped) in URL
      # and is allowed in both extN and NTFS.
      SLUGIFY_PRETTY_REGEXP
    when "ascii"
      # For web servers not being able to handle Unicode, the safe
      # method is to ditch anything else but latin letters and numeric
      # digits.
      SLUGIFY_ASCII_REGEXP
    else
      SLUGIFY_DEFAULT_REGEXP
    end
  # Strip according to the mode
  string.gsub(replaceable_char, "-")
end

def safe_glob(dir, patterns, flags = 0)
  return [] unless Dir.exist?(dir)
  pattern = File.join(Array(patterns))
  return [dir] if pattern.empty?
  Dir.chdir(dir) do
    Dir.glob(pattern, flags).map { |f| File.join(dir, f) }
  end
end

def slugify(string, mode: nil, cased: false)
  mode ||= "default"
  return nil if string.nil?
  unless SLUGIFY_MODES.include?(mode)
    return cased ? string : string.downcase
  end
  # Drop accent marks from latin characters. Everything else turns to ?
  if mode == "latin"
    I18n.config.available_locales = :en if I18n.config.available_locales.empty?
    string = I18n.transliterate(string)
  end
  slug = replace_character_sequence_with_hyphen(string, :mode => mode)
  # Remove leading/trailing hyphen
  slug.gsub!(%r!^-|-$!i, "")
  slug.downcase! unless cased
  Jekyll.logger.warn("Warning:", "Empty `slug` generated for '#{string}'.") if slug.empty?
  slug
end

def stringify_hash_keys(hash)
  transform_keys(hash) { |key| key.to_s rescue key }
end

def symbolize_hash_keys(hash)
  transform_keys(hash) { |key| key.to_sym rescue key }
end

def titleize_slug(slug)
  slug.split("-").map!(&:capitalize).join(" ")
end

def transform_keys(hash)
  result = {}
  hash.each_key do |key|
    result[yield(key)] = hash[key]
  end
  result
end

def value_from_plural_key(hash, key)
  if hash.key?(key) || (hash.default_proc && hash[key])
    val = hash[key]
    case val
    when String
      val.split
    when Array
      val.compact
    end
  end
end

def value_from_singular_key(hash, key)
  hash[key] if hash.key?(key) || (hash.default_proc && hash[key])
end