module ActionView::Helpers::UrlHelper

def _back_url # :nodoc:
  _filtered_referrer || "javascript:history.back()"
end

def _filtered_referrer # :nodoc:
  if controller.respond_to?(:request)
    referrer = controller.request.env["HTTP_REFERER"]
    if referrer && URI(referrer).scheme != "javascript"
      referrer
    end
  end
rescue URI::InvalidURIError
end

def add_method_to_attributes!(html_options, method)
  if method_not_get_method?(method) && !html_options["rel"]&.match?(/nofollow/)
    if html_options["rel"].blank?
      html_options["rel"] = "nofollow"
    else
      html_options["rel"] = "#{html_options["rel"]} nofollow"
    end
  end
  html_options["data-method"] = method
end

def button_to(name = nil, options = nil, html_options = nil, &block)
  html_options, options = options, name if block_given?
  html_options ||= {}
  html_options = html_options.stringify_keys
  url =
    case options
    when FalseClass then nil
    else url_for(options)
    end
  remote = html_options.delete("remote")
  params = html_options.delete("params")
  authenticity_token = html_options.delete("authenticity_token")
  method     = (html_options.delete("method").presence || method_for_options(options)).to_s
  method_tag = BUTTON_TAG_METHOD_VERBS.include?(method) ? method_tag(method) : "".html_safe
  form_method  = method == "get" ? "get" : "post"
  form_options = html_options.delete("form") || {}
  form_options[:class] ||= html_options.delete("form_class") || "button_to"
  form_options[:method] = form_method
  form_options[:action] = url
  form_options[:'data-remote'] = true if remote
  request_token_tag = if form_method == "post"
    request_method = method.empty? ? "post" : method
    token_tag(authenticity_token, form_options: { action: url, method: request_method })
  else
    ""
  end
  html_options = convert_options_to_data_attributes(options, html_options)
  html_options["type"] = "submit"
  button = if block_given?
    content_tag("button", html_options, &block)
  elsif button_to_generates_button_tag
    content_tag("button", name || url, html_options, &block)
  else
    html_options["value"] = name || url
    tag("input", html_options)
  end
  inner_tags = method_tag.safe_concat(button).safe_concat(request_token_tag)
  if params
    to_form_params(params).each do |param|
      inner_tags.safe_concat tag(:input, type: "hidden", name: param[:name], value: param[:value],
                                 autocomplete: "off")
    end
  end
  content_tag("form", inner_tags, form_options)
end

def convert_options_to_data_attributes(options, html_options)
  if html_options
    html_options = html_options.stringify_keys
    html_options["data-remote"] = "true" if link_to_remote_options?(options) || link_to_remote_options?(html_options)
    method = html_options.delete("method")
    add_method_to_attributes!(html_options, method) if method
    html_options
  else
    link_to_remote_options?(options) ? { "data-remote" => "true" } : {}
  end
end

def current_page?(options = nil, check_parameters: false, **options_as_kwargs)
  unless request
    raise "You cannot use helpers that need to determine the current " \
          "page unless your view context provides a Request object " \
          "in a #request method"
  end
  return false unless request.get? || request.head?
  options ||= options_as_kwargs
  check_parameters ||= options.is_a?(Hash) && options.delete(:check_parameters)
  url_string = URI::DEFAULT_PARSER.unescape(url_for(options)).force_encoding(Encoding::BINARY)
  # We ignore any extra parameters in the request_uri if the
  # submitted URL doesn't have any either. This lets the function
  # work with things like ?order=asc
  # the behaviour can be disabled with check_parameters: true
  request_uri = url_string.index("?") || check_parameters ? request.fullpath : request.path
  request_uri = URI::DEFAULT_PARSER.unescape(request_uri).force_encoding(Encoding::BINARY)
  if %r{^\w+://}.match?(url_string)
    request_uri = +"#{request.protocol}#{request.host_with_port}#{request_uri}"
  end
  remove_trailing_slash!(url_string)
  remove_trailing_slash!(request_uri)
  url_string == request_uri
end

def current_page?(*args) # :nodoc:
  options = args.pop
  options.is_a?(Hash) ? _current_page?(*args, **options) : _current_page?(*args, options)
end

def link_to(name = nil, options = nil, html_options = nil, &block)
  html_options, options, name = options, name, block if block_given?
  options ||= {}
  html_options = convert_options_to_data_attributes(options, html_options)
  url = url_target(name, options)
  html_options["href"] ||= url
  content_tag("a", name || url, html_options, &block)
end

def link_to_if(condition, name, options = {}, html_options = {}, &block)
  if condition
    link_to(name, options, html_options)
  else
    if block_given?
      block.arity <= 1 ? capture(name, &block) : capture(name, options, html_options, &block)
    else
      ERB::Util.html_escape(name)
    end
  end
end

def link_to_remote_options?(options)
  if options.is_a?(Hash)
    options.delete("remote") || options.delete(:remote)
  end
end

def link_to_unless(condition, name, options = {}, html_options = {}, &block)
  link_to_if !condition, name, options, html_options, &block
end

def link_to_unless_current(name, options = {}, html_options = {}, &block)
  link_to_unless current_page?(options), name, options, html_options, &block
end

def mail_to(email_address, name = nil, html_options = {}, &block)
  html_options, name = name, nil if name.is_a?(Hash)
  html_options = (html_options || {}).stringify_keys
  extras = %w{ cc bcc body subject reply_to }.map! { |item|
    option = html_options.delete(item).presence || next
    "#{item.dasherize}=#{ERB::Util.url_encode(option)}"
  }.compact
  extras = extras.empty? ? "" : "?" + extras.join("&")
  encoded_email_address = ERB::Util.url_encode(email_address).gsub("%40", "@")
  html_options["href"] = "mailto:#{encoded_email_address}#{extras}"
  content_tag("a", name || email_address, html_options, &block)
end

def method_for_options(options)
  if options.is_a?(Array)
    method_for_options(options.last)
  elsif options.respond_to?(:persisted?)
    options.persisted? ? :patch : :post
  elsif options.respond_to?(:to_model)
    method_for_options(options.to_model)
  end
end

def method_not_get_method?(method)
  return false unless method
  (STRINGIFIED_COMMON_METHODS[method] || method.to_s.downcase) != "get"
end

def method_tag(method)
  tag("input", type: "hidden", name: "_method", value: method.to_s, autocomplete: "off")
end

def phone_to(phone_number, name = nil, html_options = {}, &block)
  html_options, name = name, nil if name.is_a?(Hash)
  html_options = (html_options || {}).stringify_keys
  country_code = html_options.delete("country_code").presence
  country_code = country_code.nil? ? "" : "+#{ERB::Util.url_encode(country_code)}"
  encoded_phone_number = ERB::Util.url_encode(phone_number)
  html_options["href"] = "tel:#{country_code}#{encoded_phone_number}"
  content_tag("a", name || phone_number, html_options, &block)
end

def remove_trailing_slash!(url_string)
  trailing_index = (url_string.index("?") || 0) - 1
  url_string[trailing_index] = "" if url_string[trailing_index] == "/"
end

def sms_to(phone_number, name = nil, html_options = {}, &block)
  html_options, name = name, nil if name.is_a?(Hash)
  html_options = (html_options || {}).stringify_keys
  country_code = html_options.delete("country_code").presence
  country_code = country_code ? "+#{ERB::Util.url_encode(country_code)}" : ""
  body = html_options.delete("body").presence
  body = body ? "?&body=#{ERB::Util.url_encode(body)}" : ""
  encoded_phone_number = ERB::Util.url_encode(phone_number)
  html_options["href"] = "sms:#{country_code}#{encoded_phone_number};#{body}"
  content_tag("a", name || phone_number, html_options, &block)
end

def to_form_params(attribute, namespace = nil)
  attribute = if attribute.respond_to?(:permitted?)
    attribute.to_h
  else
    attribute
  end
  params = []
  case attribute
  when Hash
    attribute.each do |key, value|
      prefix = namespace ? "#{namespace}[#{key}]" : key
      params.push(*to_form_params(value, prefix))
    end
  when Array
    array_prefix = "#{namespace}[]"
    attribute.each do |value|
      params.push(*to_form_params(value, array_prefix))
    end
  else
    params << { name: namespace.to_s, value: attribute.to_param }
  end
  params.sort_by { |pair| pair[:name] }
end

def token_tag(token = nil, form_options: {})
  if token != false && defined?(protect_against_forgery?) && protect_against_forgery?
    token =
      if token == true || token.nil?
        form_authenticity_token(form_options: form_options.merge(authenticity_token: token))
      else
        token
      end
    tag(:input, type: "hidden", name: request_forgery_protection_token.to_s, value: token, autocomplete: "off")
  else
    ""
  end
end

def url_for(options = nil) # :nodoc:
  case options
  when String
    options
  when :back
    _back_url
  else
    raise ArgumentError, "arguments passed to url_for can't be handled. Please require " \
                         "routes or provide your own implementation"
  end
end

def url_target(name, options)
  if name.respond_to?(:model_name) && options.is_a?(Hash) && options.empty?
    url_for(name)
  else
    url_for(options)
  end
end