module ActionView::Helpers::AssetTagHelper

def audio_tag(*sources)
  multiple_sources_tag_builder("audio", sources)
end

def auto_discovery_link_tag(type = :rss, url_options = {}, tag_options = {})
  if !(type == :rss || type == :atom || type == :json) && tag_options[:type].blank?
    raise ArgumentError.new("You should pass :type tag_option key explicitly, because you have passed #{type} type other than :rss, :atom, or :json.")
  end
  tag(
    "link",
    "rel"   => tag_options[:rel] || "alternate",
    "type"  => tag_options[:type] || Template::Types[type].to_s,
    "title" => tag_options[:title] || type.to_s.upcase,
    "href"  => url_options.is_a?(Hash) ? url_for(url_options.merge(only_path: false)) : url_options
  )
end

def check_for_image_tag_errors(options)
  if options[:size] && (options[:height] || options[:width])
    raise ArgumentError, "Cannot pass a :size option with a :height or :width option"
  end
end

def extract_dimensions(size)
  size = size.to_s
  if /\A(\d+|\d+.\d+)x(\d+|\d+.\d+)\z/.match?(size)
    size.split("x")
  elsif /\A(\d+|\d+.\d+)\z/.match?(size)
    [size, size]
  end
end

def favicon_link_tag(source = "favicon.ico", options = {})
  tag("link", {
    rel: "icon",
    type: "image/x-icon",
    href: path_to_image(source, skip_pipeline: options.delete(:skip_pipeline))
  }.merge!(options.symbolize_keys))
end

def image_tag(source, options = {})

# =>
image_tag(user.avatar.variant(resize_to_limit: [100, 100]), size: '100')
# =>
image_tag(user.avatar.variant(resize_to_limit: [100, 100]))
# =>
image_tag(user.avatar)

Active Storage blobs (images that are uploaded by the users of your app):

# =>
image_tag("pic.jpg", srcset: [["pic_1024.jpg", "1024w"], ["pic_1980.jpg", "1980w"]], sizes: "100vw")
# =>
image_tag("icon.png", srcset: { "icon_2x.png" => "2x", "icon_4x.png" => "4x" })
# =>
image_tag("/icons/icon.gif", data: { title: 'Rails Application' })
# =>
image_tag("/icons/icon.gif", class: "menu_icon")
# =>
image_tag("/icons/icon.gif", height: '32', width: '32')
# =>
image_tag("/icons/icon.gif", size: "16")
# =>
image_tag("icon.png", size: "16x10", alt: "Edit Entry")
# =>
image_tag("icon.png")
# =>
image_tag("icon")

Assets (images that are part of your app):

==== Examples

pairs, each image path will be expanded before the list is formatted as a string.
* :srcset - If supplied as a hash or array of [source, descriptor]
:size will be ignored if the value is not in the correct format.
width="30" and height="45", and "50" becomes width="50" and height="50".
* :size - Supplied as "{Width}x{Height}" or "{Number}", so "30x45" becomes

additional keys for convenience and conformance:
You can add HTML attributes using the +options+. The +options+ supports

==== Options

path, a file, or an Active Storage attachment.
Returns an HTML image tag for the +source+. The +source+ can be a full

def image_tag(source, options = {})
  options = options.symbolize_keys
  check_for_image_tag_errors(options)
  skip_pipeline = options.delete(:skip_pipeline)
  options[:src] = resolve_image_source(source, skip_pipeline)
  if options[:srcset] && !options[:srcset].is_a?(String)
    options[:srcset] = options[:srcset].map do |src_path, size|
      src_path = path_to_image(src_path, skip_pipeline: skip_pipeline)
      "#{src_path} #{size}"
    end.join(", ")
  end
  options[:width], options[:height] = extract_dimensions(options.delete(:size)) if options[:size]
  options[:loading] ||= image_loading if image_loading
  options[:decoding] ||= image_decoding if image_decoding
  tag("img", options)
end

def javascript_include_tag(*sources)
  options = sources.extract_options!.stringify_keys
  path_options = options.extract!("protocol", "extname", "host", "skip_pipeline").symbolize_keys
  preload_links = []
  nopush = options["nopush"].nil? ? true : options.delete("nopush")
  crossorigin = options.delete("crossorigin")
  crossorigin = "anonymous" if crossorigin == true
  integrity = options["integrity"]
  rel = options["type"] == "module" ? "modulepreload" : "preload"
  sources_tags = sources.uniq.map { |source|
    href = path_to_javascript(source, path_options)
    if preload_links_header && !options["defer"] && href.present? && !href.start_with?("data:")
      preload_link = "<#{href}>; rel=#{rel}; as=script"
      preload_link += "; crossorigin=#{crossorigin}" unless crossorigin.nil?
      preload_link += "; integrity=#{integrity}" unless integrity.nil?
      preload_link += "; nopush" if nopush
      preload_links << preload_link
    end
    tag_options = {
      "src" => href,
      "crossorigin" => crossorigin
    }.merge!(options)
    if tag_options["nonce"] == true
      tag_options["nonce"] = content_security_policy_nonce
    end
    content_tag("script", "", tag_options)
  }.join("\n").html_safe
  if preload_links_header
    send_preload_links_header(preload_links)
  end
  sources_tags
end

def multiple_sources_tag_builder(type, sources)
  options       = sources.extract_options!.symbolize_keys
  skip_pipeline = options.delete(:skip_pipeline)
  sources.flatten!
  yield options if block_given?
  if sources.size > 1
    content_tag(type, options) do
      safe_join sources.map { |source| tag("source", src: send("path_to_#{type}", source, skip_pipeline: skip_pipeline)) }
    end
  else
    options[:src] = send("path_to_#{type}", sources.first, skip_pipeline: skip_pipeline)
    content_tag(type, nil, options)
  end
end

def preload_link_tag(source, options = {})
  href = path_to_asset(source, skip_pipeline: options.delete(:skip_pipeline))
  extname = File.extname(source).downcase.delete(".")
  mime_type = options.delete(:type) || Template::Types[extname]&.to_s
  as_type = options.delete(:as) || resolve_link_as(extname, mime_type)
  crossorigin = options.delete(:crossorigin)
  crossorigin = "anonymous" if crossorigin == true || (crossorigin.blank? && as_type == "font")
  integrity = options[:integrity]
  nopush = options.delete(:nopush) || false
  rel = mime_type == "module" ? "modulepreload" : "preload"
  link_tag = tag.link(**{
    rel: rel,
    href: href,
    as: as_type,
    type: mime_type,
    crossorigin: crossorigin
  }.merge!(options.symbolize_keys))
  preload_link = "<#{href}>; rel=#{rel}; as=#{as_type}"
  preload_link += "; type=#{mime_type}" if mime_type
  preload_link += "; crossorigin=#{crossorigin}" if crossorigin
  preload_link += "; integrity=#{integrity}" if integrity
  preload_link += "; nopush" if nopush
  send_preload_links_header([preload_link])
  link_tag
end

def resolve_image_source(source, skip_pipeline)
  if source.is_a?(Symbol) || source.is_a?(String)
    path_to_image(source, skip_pipeline: skip_pipeline)
  else
    polymorphic_url(source)
  end
rescue NoMethodError => e
  raise ArgumentError, "Can't resolve image into URL: #{e}"
end

def resolve_link_as(extname, mime_type)
  case extname
  when "js"  then "script"
  when "css" then "style"
  when "vtt" then "track"
  else
    mime_type.to_s.split("/").first.presence_in(%w(audio video font image))
  end
end

def send_preload_links_header(preload_links, max_header_size: MAX_HEADER_SIZE)
  return if preload_links.empty?
  return if respond_to?(:response) && response&.sending?
  if respond_to?(:request) && request
    request.send_early_hints("Link" => preload_links.join("\n"))
  end
  if respond_to?(:response) && response
    header = response.headers["Link"]
    header = header ? header.dup : +""
    # rindex count characters not bytes, but we assume non-ascii characters
    # are rare in urls, and we have a 192 bytes margin.
    last_line_offset = header.rindex("\n")
    last_line_size = if last_line_offset
      header.bytesize - last_line_offset
    else
      header.bytesize
    end
    preload_links.each do |link|
      if link.bytesize + last_line_size + 1 < max_header_size
        unless header.empty?
          header << ","
          last_line_size += 1
        end
      else
        header << "\n"
        last_line_size = 0
      end
      header << link
      last_line_size += link.bytesize
    end
    response.headers["Link"] = header
  end
end

def stylesheet_link_tag(*sources)
  options = sources.extract_options!.stringify_keys
  path_options = options.extract!("protocol", "extname", "host", "skip_pipeline").symbolize_keys
  preload_links = []
  crossorigin = options.delete("crossorigin")
  crossorigin = "anonymous" if crossorigin == true
  nopush = options["nopush"].nil? ? true : options.delete("nopush")
  integrity = options["integrity"]
  sources_tags = sources.uniq.map { |source|
    href = path_to_stylesheet(source, path_options)
    if preload_links_header && href.present? && !href.start_with?("data:")
      preload_link = "<#{href}>; rel=preload; as=style"
      preload_link += "; crossorigin=#{crossorigin}" unless crossorigin.nil?
      preload_link += "; integrity=#{integrity}" unless integrity.nil?
      preload_link += "; nopush" if nopush
      preload_links << preload_link
    end
    tag_options = {
      "rel" => "stylesheet",
      "crossorigin" => crossorigin,
      "href" => href
    }.merge!(options)
    if apply_stylesheet_media_default && tag_options["media"].blank?
      tag_options["media"] = "screen"
    end
    tag(:link, tag_options)
  }.join("\n").html_safe
  if preload_links_header
    send_preload_links_header(preload_links)
  end
  sources_tags
end

def video_tag(*sources)
  options = sources.extract_options!.symbolize_keys
  public_poster_folder = options.delete(:poster_skip_pipeline)
  sources << options
  multiple_sources_tag_builder("video", sources) do |tag_options|
    tag_options[:poster] = path_to_image(tag_options[:poster], skip_pipeline: public_poster_folder) if tag_options[:poster]
    tag_options[:width], tag_options[:height] = extract_dimensions(tag_options.delete(:size)) if tag_options[:size]
  end
end