class SimpleForm::FormBuilder

def self.discovery_cache
  @discovery_cache ||= {}
end

def association(association, options = {}, &block)
  options = options.dup
  return simple_fields_for(*[association,
    options.delete(:collection), options].compact, &block) if block_given?
  raise ArgumentError, "Association cannot be used in forms not associated with an object" unless @object
  reflection = find_association_reflection(association)
  raise "Association #{association.inspect} not found" unless reflection
  options[:as] ||= :select
  options[:collection] ||= fetch_association_collection(reflection, options)
  attribute = build_association_attribute(reflection, association, options)
  input(attribute, options.merge(reflection: reflection))
end

def attempt_mapping(mapping, at)
  return if SimpleForm.inputs_discovery == false && at == Object
  begin
    at.const_get(mapping)
  rescue NameError => e
    raise unless e.message.include?(mapping)
  end
end

def attempt_mapping_with_custom_namespace(input_name)
  SimpleForm.custom_inputs_namespaces.each do |namespace|
    if (mapping = attempt_mapping(input_name, namespace.constantize))
      return mapping
    end
  end
  nil
end

def build_association_attribute(reflection, association, options)
  case reflection.macro
  when :belongs_to
    (reflection.respond_to?(:options) && reflection.options[:foreign_key]) || :"#{reflection.name}_id"
  when :has_one
    raise ArgumentError, ":has_one associations are not supported by f.association"
  else
    if options[:as] == :select || options[:as] == :grouped_select
      html_options = options[:input_html] ||= {}
      html_options[:multiple] = true unless html_options.key?(:multiple)
    end
    # Force the association to be preloaded for performance.
    if options[:preload] != false && object.respond_to?(association)
      target = object.send(association)
      target.to_a if target.respond_to?(:to_a)
    end
    :"#{reflection.name.to_s.singularize}_ids"
  end
end

def build_input_field_components(components)
  components.map do |component|
    if component == :input
      SimpleForm::Wrappers::Leaf.new(component, build_input_field_options)
    else
      SimpleForm::Wrappers::Leaf.new(component)
    end
  end
end

def build_input_field_options
  input_field_options = {}
  valid_class         = SimpleForm.input_field_valid_class
  error_class         = SimpleForm.input_field_error_class
  if error_class.present?
    input_field_options[:error_class] = error_class
  end
  if valid_class.present?
    input_field_options[:valid_class] = valid_class
  end
  input_field_options
end

def button(type, *args, &block)
  options = args.extract_options!.dup
  options[:class] = [SimpleForm.button_class, options[:class]].compact
  args << options
  if respond_to?(:"#{type}_button")
    send(:"#{type}_button", *args, &block)
  else
    send(type, *args, &block)
  end
end

def collection_check_boxes(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
  SimpleForm::Tags::CollectionCheckBoxes.new(@object_name, method, @template, collection, value_method, text_method, objectify_options(options), @default_options.merge(html_options)).render(&block)
end

def collection_radio_buttons(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
  SimpleForm::Tags::CollectionRadioButtons.new(@object_name, method, @template, collection, value_method, text_method, objectify_options(options), @default_options.merge(html_options)).render(&block)
end

def default_input_type(attribute_name, column, options)
  return options[:as].to_sym if options[:as]
  custom_type = find_custom_type(attribute_name.to_s) and return custom_type
  return :select             if options[:collection]
  input_type = column.try(:type)
  case input_type
  when :timestamp
    :datetime
  when :string, :citext, nil
    case attribute_name.to_s
    when /(?:\b|\W|_)password(?:\b|\W|_)/  then :password
    when /(?:\b|\W|_)time_zone(?:\b|\W|_)/ then :time_zone
    when /(?:\b|\W|_)country(?:\b|\W|_)/   then :country
    when /(?:\b|\W|_)email(?:\b|\W|_)/     then :email
    when /(?:\b|\W|_)phone(?:\b|\W|_)/     then :tel
    when /(?:\b|\W|_)url(?:\b|\W|_)/       then :url
    else
      file_method?(attribute_name) ? :file : (input_type || :string)
    end
  else
    input_type
  end
end

def discovery_cache
  if SimpleForm.cache_discovery
    self.class.discovery_cache
  else
    @discovery_cache ||= {}
  end
end

def error(attribute_name, options = {})
  options = options.dup
  options[:error_html] = options.except(:error_tag, :error_prefix, :error_method)
  column      = find_attribute_column(attribute_name)
  input_type  = default_input_type(attribute_name, column, options)
  wrapper.find(:error).
    render(SimpleForm::Inputs::Base.new(self, attribute_name, column, input_type, options))
end

def error_notification(options = {})
  SimpleForm::ErrorNotification.new(self, options).render
end

def fetch_association_collection(reflection, options)
  options.fetch(:collection) do
    relation = reflection.klass.all
    if reflection.respond_to?(:scope) && reflection.scope
      if reflection.scope.parameters.any?
        relation = reflection.klass.instance_exec(object, &reflection.scope)
      else
        relation = reflection.klass.instance_exec(&reflection.scope)
      end
    else
      order = reflection.options[:order]
      conditions = reflection.options[:conditions]
      conditions = object.instance_exec(&conditions) if conditions.respond_to?(:call)
      relation = relation.where(conditions) if relation.respond_to?(:where) && conditions.present?
      relation = relation.order(order) if relation.respond_to?(:order)
    end
    relation
  end
end

def file_method?(attribute_name)
  @object.respond_to?("#{attribute_name}_attachment") ||
    @object.respond_to?("#{attribute_name}_attachments") ||
    @object.respond_to?("remote_#{attribute_name}_url") ||
    @object.respond_to?("#{attribute_name}_attacher") ||
    @object.respond_to?("#{attribute_name}_file_name")
end

def find_association_reflection(association)
  if @object.class.respond_to?(:reflect_on_association)
    @object.class.reflect_on_association(association)
  end
end

def find_attribute_column(attribute_name)
  if @object.respond_to?(:type_for_attribute) && @object.has_attribute?(attribute_name)
    @object.type_for_attribute(attribute_name.to_s)
  elsif @object.respond_to?(:column_for_attribute) && @object.has_attribute?(attribute_name)
    @object.column_for_attribute(attribute_name)
  end
end

def find_custom_type(attribute_name)
  SimpleForm.input_mappings.find { |match, type|
    attribute_name =~ match
  }.try(:last) if SimpleForm.input_mappings
end

def find_input(attribute_name, options = {}, &block)
  column     = find_attribute_column(attribute_name)
  input_type = default_input_type(attribute_name, column, options)
  if block_given?
    SimpleForm::Inputs::BlockInput.new(self, attribute_name, column, input_type, options, &block)
  else
    find_mapping(input_type).new(self, attribute_name, column, input_type, options)
  end
end

def find_mapping(input_type)
  discovery_cache[input_type] ||=
    if mapping = self.class.mappings[input_type]
      mapping_override(mapping) || mapping
    else
      camelized = "#{input_type.to_s.camelize}Input"
      attempt_mapping_with_custom_namespace(camelized) ||
        attempt_mapping(camelized, Object) ||
        attempt_mapping(camelized, self.class) ||
        raise("No input found for #{input_type}")
    end
end

def find_wrapper(input_type, options)
  if name = options[:wrapper] || find_wrapper_mapping(input_type)
    name.respond_to?(:render) ? name : SimpleForm.wrapper(name)
  else
    wrapper
  end
end

def find_wrapper_mapping(input_type)
  if options[:wrapper_mappings] && options[:wrapper_mappings][input_type]
    options[:wrapper_mappings][input_type]
  else
    SimpleForm.wrapper_mappings && SimpleForm.wrapper_mappings[input_type]
  end
end

def full_error(attribute_name, options = {})
  options = options.dup
  options[:error_prefix] ||= if object.class.respond_to?(:human_attribute_name)
    object.class.human_attribute_name(attribute_name.to_s)
  else
    attribute_name.to_s.humanize
  end
  error(attribute_name, options)
end

def hint(attribute_name, options = {})
  options = options.dup
  options[:hint_html] = options.except(:hint_tag, :hint)
  if attribute_name.is_a?(String)
    options[:hint] = attribute_name
    attribute_name, column, input_type = nil, nil, nil
  else
    column      = find_attribute_column(attribute_name)
    input_type  = default_input_type(attribute_name, column, options)
  end
  wrapper.find(:hint).
    render(SimpleForm::Inputs::Base.new(self, attribute_name, column, input_type, options))
end

def initialize(*) #:nodoc:
  super
  @object   = convert_to_model(@object)
  @defaults = options[:defaults]
  @wrapper  = SimpleForm.wrapper(options[:wrapper] || SimpleForm.default_wrapper)
end

def input(attribute_name, options = {}, &block)
  options = @defaults.deep_dup.deep_merge(options) if @defaults
  input   = find_input(attribute_name, options, &block)
  wrapper = find_wrapper(input.input_type, options)
  wrapper.render input
end

def input_field(attribute_name, options = {})
  components = (wrapper.components.map(&:namespace) & ATTRIBUTE_COMPONENTS)
  options = options.dup
  options[:input_html] = options.except(:as, :boolean_style, :collection, :disabled, :label_method, :value_method, :prompt, *components)
  options = @defaults.deep_dup.deep_merge(options) if @defaults
  input      = find_input(attribute_name, options)
  wrapper    = find_wrapper(input.input_type, options)
  components = build_input_field_components(components.push(:input))
  SimpleForm::Wrappers::Root.new(components, wrapper.options.merge(wrapper: false)).render input
end

def label(attribute_name, *args)
  return super if args.first.is_a?(String) || block_given?
  options = args.extract_options!.dup
  options[:label_html] = options.except(:label, :label_text, :required, :as)
  column      = find_attribute_column(attribute_name)
  input_type  = default_input_type(attribute_name, column, options)
  SimpleForm::Inputs::Base.new(self, attribute_name, column, input_type, options).label
end

def lookup_action #:nodoc:
  @lookup_action ||= begin
    action = template.controller && template.controller.action_name
    return unless action
    action = action.to_s
    ACTIONS[action] || action
  end
end

def lookup_model_names #:nodoc:
  @lookup_model_names ||= begin
    child_index = options[:child_index]
    names = object_name.to_s.scan(/(?!\d)\w+/).flatten
    names.delete(child_index) if child_index
    names.each { |name| name.gsub!('_attributes', '') }
    names.freeze
  end
end

def mapping_override(klass)
  name = klass.name
  if name =~ /^SimpleForm::Inputs/
    input_name = name.split("::").last
    attempt_mapping_with_custom_namespace(input_name) ||
      attempt_mapping(input_name, Object)
  end
end