module ActionView::Helpers::InstanceTagMethods

def add_default_name_and_id(options)
  if options.has_key?("index")
    options["name"] ||= tag_name_with_index(options["index"])
    options["id"] = options.fetch("id"){ tag_id_with_index(options["index"]) }
    options.delete("index")
  elsif defined?(@auto_index)
    options["name"] ||= tag_name_with_index(@auto_index)
    options["id"] = options.fetch("id"){ tag_id_with_index(@auto_index) }
  else
    options["name"] ||= tag_name + (options['multiple'] ? '[]' : '')
    options["id"] = options.fetch("id"){ tag_id }
  end
end

def add_default_name_and_id_for_value(tag_value, options)
  unless tag_value.nil?
    pretty_tag_value = tag_value.to_s.gsub(/\s/, "_").gsub(/[^-\w]/, "").downcase
    specified_id = options["id"]
    add_default_name_and_id(options)
    options["id"] += "_#{pretty_tag_value}" if specified_id.blank? && options["id"].present?
  else
    add_default_name_and_id(options)
  end
end

def initialize(object_name, method_name, template_object, object = nil)
  @object_name, @method_name = object_name.to_s.dup, method_name.to_s.dup
  @template_object = template_object
  @object = object
  if @object_name.sub!(/\[\]$/,"") || @object_name.sub!(/\[\]\]$/,"]")
    if (object ||= @template_object.instance_variable_get("@#{Regexp.last_match.pre_match}")) && object.respond_to?(:to_param)
      @auto_index = object.to_param
    else
      raise ArgumentError, "object[] naming but object param and @object var don't exist or don't respond to to_param: #{object.inspect}"
    end
  end
end

def object
  @object || @template_object.instance_variable_get("@#{@object_name}")
rescue NameError
  # As @object_name may contain the nested syntax (item[subobject]) we
  # need to fallback to nil.
  nil
end

def sanitized_method_name
  @sanitized_method_name ||= @method_name.sub(/\?$/,"")
end

def sanitized_object_name
  @sanitized_object_name ||= @object_name.gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").sub(/_$/, "")
end

def tag_id
  "#{sanitized_object_name}_#{sanitized_method_name}"
end

def tag_id_with_index(index)
  "#{sanitized_object_name}_#{index}_#{sanitized_method_name}"
end

def tag_name
  "#{@object_name}[#{sanitized_method_name}]"
end

def tag_name_with_index(index)
  "#{@object_name}[#{index}][#{sanitized_method_name}]"
end

def to_boolean_select_tag(options = {})
  options = options.stringify_keys
  add_default_name_and_id(options)
  value = value(object)
  tag_text = "<select"
  tag_text << tag_options(options)
  tag_text << "><option value=\"false\""
  tag_text << " selected" if value == false
  tag_text << ">False</option><option value=\"true\""
  tag_text << " selected" if value
  tag_text << ">True</option></select>"
end

def to_check_box_tag(options = {}, checked_value = "1", unchecked_value = "0")
  options = options.stringify_keys
  options["type"]     = "checkbox"
  options["value"]    = checked_value
  if options.has_key?("checked")
    cv = options.delete "checked"
    checked = cv == true || cv == "checked"
  else
    checked = self.class.check_box_checked?(value(object), checked_value)
  end
  options["checked"] = "checked" if checked
  if options["multiple"]
    add_default_name_and_id_for_value(checked_value, options)
    options.delete("multiple")
  else
    add_default_name_and_id(options)
  end
  hidden = tag("input", "name" => options["name"], "type" => "hidden", "value" => options['disabled'] && checked ? checked_value : unchecked_value)
  checkbox = tag("input", options)
  (hidden + checkbox).html_safe
end

def to_content_tag(tag_name, options = {})
  content_tag(tag_name, value(object), options)
end

def to_input_field_tag(field_type, options = {})
  options = options.stringify_keys
  options["size"] = options["maxlength"] || DEFAULT_FIELD_OPTIONS["size"] unless options.key?("size")
  options = DEFAULT_FIELD_OPTIONS.merge(options)
  if field_type == "hidden"
    options.delete("size")
  end
  options["type"]  ||= field_type
  options["value"] = options.fetch("value"){ value_before_type_cast(object) } unless field_type == "file"
  options["value"] &&= html_escape(options["value"])
  add_default_name_and_id(options)
  tag("input", options)
end

def to_label_tag(text = nil, options = {}, &block)
  options = options.stringify_keys
  tag_value = options.delete("value")
  name_and_id = options.dup
  if name_and_id["for"]
    name_and_id["id"] = name_and_id["for"]
  else
    name_and_id.delete("id")
  end
  add_default_name_and_id_for_value(tag_value, name_and_id)
  options.delete("index")
  options["for"] ||= name_and_id["id"]
  if block_given?
    label_tag(name_and_id["id"], options, &block)
  else
    content = if text.blank?
      I18n.t("helpers.label.#{object_name}.#{method_name}", :default => "").presence
    else
      text.to_s
    end
    content ||= if object && object.class.respond_to?(:human_attribute_name)
      object.class.human_attribute_name(method_name)
    end
    content ||= method_name.humanize
    label_tag(name_and_id["id"], content, options)
  end
end

def to_number_field_tag(field_type, options = {})
  options = options.stringify_keys
  if range = options.delete("in") || options.delete("within")
    options.update("min" => range.min, "max" => range.max)
  end
  to_input_field_tag(field_type, options)
end

def to_radio_button_tag(tag_value, options = {})
  options = DEFAULT_RADIO_OPTIONS.merge(options.stringify_keys)
  options["type"]     = "radio"
  options["value"]    = tag_value
  if options.has_key?("checked")
    cv = options.delete "checked"
    checked = cv == true || cv == "checked"
  else
    checked = self.class.radio_button_checked?(value(object), tag_value)
  end
  options["checked"]  = "checked" if checked
  add_default_name_and_id_for_value(tag_value, options)
  tag("input", options)
end

def to_text_area_tag(options = {})
  options = DEFAULT_TEXT_AREA_OPTIONS.merge(options.stringify_keys)
  add_default_name_and_id(options)
  if size = options.delete("size")
    options["cols"], options["rows"] = size.split("x") if size.respond_to?(:split)
  end
  content_tag("textarea", html_escape(options.delete('value') || value_before_type_cast(object)), options)
end

def value(object)
  self.class.value(object, @method_name)
end

def value_before_type_cast(object)
  self.class.value_before_type_cast(object, @method_name)
end