module ActionView::Helpers::UrlHelper

def add_confirm_to_attributes!(html_options, confirm)
  html_options["data-confirm"] = confirm if confirm
end

def add_method_to_attributes!(html_options, method)
  html_options["rel"] = "nofollow" if method && method.to_s.downcase != "get"
  html_options["data-method"] = method if method
end

def array_or_string_for_javascript(option)
  if option.kind_of?(Array)
    "['#{option.join('\',\'')}']"
  elsif !option.nil?
    "'#{option}'"
  end
end

def button_to(name, options = {}, html_options = {})
  html_options = html_options.stringify_keys
  convert_boolean_attributes!(html_options, %w( disabled ))
  method_tag = ''
  if (method = html_options.delete('method')) && %w{put delete}.include?(method.to_s)
    method_tag = tag('input', :type => 'hidden', :name => '_method', :value => method.to_s)
  end
  form_method = method.to_s == 'get' ? 'get' : 'post'
  remote = html_options.delete('remote')
  request_token_tag = ''
  if form_method == 'post' && protect_against_forgery?
    request_token_tag = tag(:input, :type => "hidden", :name => request_forgery_protection_token.to_s, :value => form_authenticity_token)
  end
  url = options.is_a?(String) ? options : self.url_for(options)
  name ||= url
  html_options = convert_options_to_data_attributes(options, html_options)
  html_options.merge!("type" => "submit", "value" => name)
  ("<form method=\"#{form_method}\" action=\"#{html_escape(url)}\" #{"data-remote=\"true\"" if remote} class=\"button_to\"><div>" +
    method_tag + tag("input", html_options) + request_token_tag + "</div></form>").html_safe
end

def convert_boolean_attributes!(html_options, bool_attrs)
  bool_attrs.each { |x| html_options[x] = x if html_options.delete(x) }
  html_options
end

def convert_options_to_data_attributes(options, html_options)
  html_options = {} if html_options.nil?
  html_options = html_options.stringify_keys
  if (options.is_a?(Hash) && options.key?('remote') && options.delete('remote')) || (html_options.is_a?(Hash) && html_options.key?('remote') && html_options.delete('remote'))
    html_options['data-remote'] = 'true'
  end
  confirm = html_options.delete("confirm")
  if html_options.key?("popup")
    ActiveSupport::Deprecation.warn(":popup has been deprecated", caller)
  end
  method, href = html_options.delete("method"), html_options['href']
  add_confirm_to_attributes!(html_options, confirm) if confirm
  add_method_to_attributes!(html_options, method)   if method
  html_options
end

def current_page?(options)
  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
  url_string = url_for(options)
  # 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
  if url_string.index("?")
    request_uri = request.fullpath
  else
    request_uri = request.path
  end
  if url_string =~ /^\w+:\/\//
    url_string == "#{request.protocol}#{request.host_with_port}#{request_uri}"
  else
    url_string == request_uri
  end
end

def link_to(*args, &block)
  if block_given?
    options      = args.first || {}
    html_options = args.second
    link_to(capture(&block), options, html_options)
  else
    name         = args[0]
    options      = args[1] || {}
    html_options = args[2]
    html_options = convert_options_to_data_attributes(options, html_options)
    url = url_for(options)
    if html_options
      html_options = html_options.stringify_keys
      href = html_options['href']
      tag_options = tag_options(html_options)
    else
      tag_options = nil
    end
    href_attr = "href=\"#{html_escape(url)}\"" unless href
    "<a #{href_attr}#{tag_options}>#{html_escape(name || url)}</a>".html_safe
  end
end

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

def link_to_unless(condition, name, options = {}, html_options = {}, &block)
  if condition
    if block_given?
      block.arity <= 1 ? capture(name, &block) : capture(name, options, html_options, &block)
    else
      name
    end
  else
    link_to(name, options, html_options)
  end
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 = {})
  email_address = html_escape(email_address)
  html_options = html_options.stringify_keys
  encode = html_options.delete("encode").to_s
  cc, bcc, subject, body = html_options.delete("cc"), html_options.delete("bcc"), html_options.delete("subject"), html_options.delete("body")
  extras = []
  extras << "cc=#{Rack::Utils.escape(cc).gsub("+", "%20")}" unless cc.nil?
  extras << "bcc=#{Rack::Utils.escape(bcc).gsub("+", "%20")}" unless bcc.nil?
  extras << "body=#{Rack::Utils.escape(body).gsub("+", "%20")}" unless body.nil?
  extras << "subject=#{Rack::Utils.escape(subject).gsub("+", "%20")}" unless subject.nil?
  extras = extras.empty? ? '' : '?' + html_escape(extras.join('&'))
  email_address_obfuscated = email_address.dup
  email_address_obfuscated.gsub!(/@/, html_options.delete("replace_at")) if html_options.has_key?("replace_at")
  email_address_obfuscated.gsub!(/\./, html_options.delete("replace_dot")) if html_options.has_key?("replace_dot")
  string = ''
  if encode == "javascript"
    "document.write('#{content_tag("a", name || email_address_obfuscated.html_safe, html_options.merge("href" => "mailto:#{email_address}#{extras}".html_safe))}');".each_byte do |c|
      string << sprintf("%%%x", c)
    end
    "<script type=\"#{Mime::JS}\">eval(decodeURIComponent('#{string}'))</script>".html_safe
  elsif encode == "hex"
    email_address_encoded = ''
    email_address_obfuscated.each_byte do |c|
      email_address_encoded << sprintf("&#%d;", c)
    end
    protocol = 'mailto:'
    protocol.each_byte { |c| string << sprintf("&#%d;", c) }
    email_address.each_byte do |c|
      char = c.chr
      string << (char =~ /\w/ ? sprintf("%%%x", c) : char)
    end
    content_tag "a", name || email_address_encoded.html_safe, html_options.merge("href" => "#{string}#{extras}".html_safe)
  else
    content_tag "a", name || email_address_obfuscated.html_safe, html_options.merge("href" => "mailto:#{email_address}#{extras}".html_safe)
  end
end

def options_for_javascript(options)
  if options.empty?
    '{}'
  else
    "{#{options.keys.map { |k| "#{k}:#{options[k]}" }.sort.join(', ')}}"
  end
end

def url_for(options = {})
  options ||= {}
  url = case options
  when String
    options
  when Hash
    options = options.symbolize_keys.reverse_merge!(:only_path => options[:host].nil?)
    super
  when :back
    controller.request.env["HTTP_REFERER"] || 'javascript:history.back()'
  else
    polymorphic_path(options)
  end
  url
end

def url_options
  return super unless controller.respond_to?(:url_options)
  controller.url_options
end