module ActionView::Helpers::FormTagHelper

def button_tag(content_or_options = nil, options = nil, &block)
  if content_or_options.is_a? Hash
    options = content_or_options
  else
    options ||= {}
  end
  options = { "name" => "button", "type" => "submit" }.merge!(options.stringify_keys)
  if block_given?
    content_tag :button, options, &block
  else
    content_tag :button, content_or_options || "Button", options
  end
end

def check_box_tag(name, value = "1", checked = false, options = {})
  html_options = { "type" => "checkbox", "name" => name, "id" => sanitize_to_id(name), "value" => value }.update(options.stringify_keys)
  html_options["checked"] = "checked" if checked
  tag :input, html_options
end

def color_field_tag(name, value = nil, options = {})
  text_field_tag(name, value, options.merge(type: :color))
end

def convert_direct_upload_option_to_url(options)
  if options.delete(:direct_upload) && respond_to?(:rails_direct_uploads_url)
    options["data-direct-upload-url"] = rails_direct_uploads_url
  end
  options
end

def date_field_tag(name, value = nil, options = {})
  text_field_tag(name, value, options.merge(type: :date))
end

def datetime_field_tag(name, value = nil, options = {})
  text_field_tag(name, value, options.merge(type: "datetime-local"))
end

def email_field_tag(name, value = nil, options = {})
  text_field_tag(name, value, options.merge(type: :email))
end

def extra_tags_for_form(html_options)
  authenticity_token = html_options.delete("authenticity_token")
  method = html_options.delete("method").to_s.downcase
  method_tag = \
    case method
    when "get"
      html_options["method"] = "get"
      ""
    when "post", ""
      html_options["method"] = "post"
      token_tag(authenticity_token, form_options: {
        action: html_options["action"],
        method: "post"
      })
    else
      html_options["method"] = "post"
      method_tag(method) + token_tag(authenticity_token, form_options: {
        action: html_options["action"],
        method: method
      })
    end
  if html_options.delete("enforce_utf8") { default_enforce_utf8 }
    utf8_enforcer_tag + method_tag
  else
    method_tag
  end
end

def field_id(object_name, method_name, *suffixes, index: nil, namespace: nil)
  if object_name.respond_to?(:model_name)
    object_name = object_name.model_name.singular
  end
  sanitized_object_name = object_name.to_s.gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").delete_suffix("_")
  sanitized_method_name = method_name.to_s.delete_suffix("?")
  [
    namespace,
    sanitized_object_name.presence,
    (index unless sanitized_object_name.empty?),
    sanitized_method_name,
    *suffixes,
  ].tap(&:compact!).join("_")
end

def field_name(object_name, method_name, *method_names, multiple: false, index: nil)
  names = method_names.map! { |name| "[#{name}]" }.join
  # a little duplication to construct fewer strings
  case
  when object_name.blank?
    "#{method_name}#{names}#{multiple ? "[]" : ""}"
  when index
    "#{object_name}[#{index}][#{method_name}]#{names}#{multiple ? "[]" : ""}"
  else
    "#{object_name}[#{method_name}]#{names}#{multiple ? "[]" : ""}"
  end
end

def field_set_tag(legend = nil, options = nil, &block)
  output = tag(:fieldset, options, true)
  output.safe_concat(content_tag("legend", legend)) unless legend.blank?
  output.concat(capture(&block)) if block_given?
  output.safe_concat("</fieldset>")
end

def file_field_tag(name, options = {})
  text_field_tag(name, nil, convert_direct_upload_option_to_url(options.merge(type: :file)))
end

def form_tag(url_for_options = {}, options = {}, &block)
  html_options = html_options_for_form(url_for_options, options)
  if block_given?
    form_tag_with_body(html_options, capture(&block))
  else
    form_tag_html(html_options)
  end
end

def form_tag_html(html_options)
  extra_tags = extra_tags_for_form(html_options)
  tag(:form, html_options, true) + extra_tags
end

def form_tag_with_body(html_options, content)
  output = form_tag_html(html_options)
  output << content.to_s if content
  output.safe_concat("</form>")
end

def hidden_field_tag(name, value = nil, options = {})
  text_field_tag(name, value, options.merge(type: :hidden, autocomplete: "off"))
end

def html_options_for_form(url_for_options, options)
  options.stringify_keys.tap do |html_options|
    html_options["enctype"] = "multipart/form-data" if html_options.delete("multipart")
    # The following URL is unescaped, this is just a hash of options, and it is the
    # responsibility of the caller to escape all the values.
    if url_for_options == false || html_options["action"] == false
      html_options.delete("action")
    else
      html_options["action"] = url_for(url_for_options)
    end
    html_options["accept-charset"] = "UTF-8"
    html_options["data-remote"] = true if html_options.delete("remote")
    if html_options["data-remote"] &&
       embed_authenticity_token_in_remote_forms == false &&
       html_options["authenticity_token"].blank?
      # The authenticity token is taken from the meta tag in this case
      html_options["authenticity_token"] = false
    elsif html_options["authenticity_token"] == true
      # Include the default authenticity_token, which is only generated when its set to nil,
      # but we needed the true value to override the default of no authenticity_token on data-remote.
      html_options["authenticity_token"] = nil
    end
  end
end

def image_submit_tag(source, options = {})
  options = options.stringify_keys
  src = path_to_image(source, skip_pipeline: options.delete("skip_pipeline"))
  tag :input, { "type" => "image", "src" => src }.update(options)
end

def label_tag(name = nil, content_or_options = nil, options = nil, &block)
  if block_given? && content_or_options.is_a?(Hash)
    options = content_or_options = content_or_options.stringify_keys
  else
    options ||= {}
    options = options.stringify_keys
  end
  options["for"] = sanitize_to_id(name) unless name.blank? || options.has_key?("for")
  content_tag :label, content_or_options || name.to_s.humanize, options, &block
end

def month_field_tag(name, value = nil, options = {})
  text_field_tag(name, value, options.merge(type: :month))
end

def number_field_tag(name, value = nil, options = {})
  options = options.stringify_keys
  options["type"] ||= "number"
  if range = options.delete("in") || options.delete("within")
    options.update("min" => range.min, "max" => range.max)
  end
  text_field_tag(name, value, options)
end

def password_field_tag(name = "password", value = nil, options = {})
  text_field_tag(name, value, options.merge(type: :password))
end

def radio_button_tag(name, value, checked = false, options = {})
  html_options = { "type" => "radio", "name" => name, "id" => "#{sanitize_to_id(name)}_#{sanitize_to_id(value)}", "value" => value }.update(options.stringify_keys)
  html_options["checked"] = "checked" if checked
  tag :input, html_options
end

def range_field_tag(name, value = nil, options = {})
  number_field_tag(name, value, options.merge(type: :range))
end

def sanitize_to_id(name)
  name.to_s.delete("]").tr("^-a-zA-Z0-9:.", "_")
end

def search_field_tag(name, value = nil, options = {})
  text_field_tag(name, value, options.merge(type: :search))
end

def select_tag(name, option_tags = nil, options = {})
  option_tags ||= ""
  html_name = (options[:multiple] == true && !name.end_with?("[]")) ? "#{name}[]" : name
  if options.include?(:include_blank)
    include_blank = options[:include_blank]
    options = options.except(:include_blank)
    options_for_blank_options_tag = { value: "" }
    if include_blank == true
      include_blank = ""
      options_for_blank_options_tag[:label] = " "
    end
    if include_blank
      option_tags = content_tag("option", include_blank, options_for_blank_options_tag).safe_concat(option_tags)
    end
  end
  if prompt = options.delete(:prompt)
    option_tags = content_tag("option", prompt, value: "").safe_concat(option_tags)
  end
  content_tag "select", option_tags, { "name" => html_name, "id" => sanitize_to_id(name) }.update(options.stringify_keys)
end

def set_default_disable_with(value, tag_options)
  data = tag_options.fetch("data", {})
  if tag_options["data-disable-with"] == false || data["disable_with"] == false
    data.delete("disable_with")
  elsif ActionView::Base.automatically_disable_submit_tag
    disable_with_text = tag_options["data-disable-with"]
    disable_with_text ||= data["disable_with"]
    disable_with_text ||= value.to_s.clone
    tag_options.deep_merge!("data" => { "disable_with" => disable_with_text })
  end
  tag_options.delete("data-disable-with")
end

def submit_tag(value = "Save changes", options = {})
  options = options.deep_stringify_keys
  tag_options = { "type" => "submit", "name" => "commit", "value" => value }.update(options)
  set_default_disable_with value, tag_options
  tag :input, tag_options
end

def telephone_field_tag(name, value = nil, options = {})
  text_field_tag(name, value, options.merge(type: :tel))
end

def text_area_tag(name, content = nil, options = {})
  options = options.stringify_keys
  if size = options.delete("size")
    options["cols"], options["rows"] = size.split("x") if size.respond_to?(:split)
  end
  escape = options.delete("escape") { true }
  content = ERB::Util.html_escape(content) if escape
  content_tag :textarea, content.to_s.html_safe, { "name" => name, "id" => sanitize_to_id(name) }.update(options)
end

def text_field_tag(name, value = nil, options = {})
  tag :input, { "type" => "text", "name" => name, "id" => sanitize_to_id(name), "value" => value }.update(options.stringify_keys)
end

def time_field_tag(name, value = nil, options = {})
  text_field_tag(name, value, options.merge(type: :time))
end

def url_field_tag(name, value = nil, options = {})
  text_field_tag(name, value, options.merge(type: :url))
end

def utf8_enforcer_tag
  # Use raw HTML to ensure the value is written as an HTML entity; it
  # needs to be the right character regardless of which encoding the
  # browser infers.
  '<input name="utf8" type="hidden" value="&#x2713;" autocomplete="off" />'.html_safe
end

def week_field_tag(name, value = nil, options = {})
  text_field_tag(name, value, options.merge(type: :week))
end