class SimpleForm::FormBuilder

def association(association, options={}, &block)
  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
  options[:as] ||= :select
  @reflection = find_association_reflection(association)
  raise "Association #{association.inspect} not found" unless @reflection
  case @reflection.macro
    when :belongs_to
      attribute = @reflection.options[:foreign_key] || :"#{@reflection.name}_id"
    when :has_one
      raise ":has_one association are not supported by f.association"
    else
      attribute = :"#{@reflection.name.to_s.singularize}_ids"
      if options[:as] == :select
        html_options = options[:input_html] ||= {}
        html_options[:size]   ||= 5
        html_options[:multiple] = true unless html_options.key?(:multiple)
      end
  end
  options[:collection] ||= begin
    finders = options.slice(:conditions, :order, :include, :joins)
    finders[:conditions] = @reflection.klass.merge_conditions(finders[:conditions],
      @reflection.options[:conditions])
    klass = Array(options[:scope]).inject(@reflection.klass) do |klass, scope|
      klass.send(scope)
    end
    klass.all(finders)
  end
  returning(input(attribute, options)) { @reflection = nil }
end

def button(type, *args)
  options = args.extract_options!
  value   = args.first || options.delete(:label)
  key     = @object ? (@object.new_record? ? :create : :update) : :submit
  value ||= begin
    model = if @object.class.respond_to?(:human_name)
      @object.class.human_name
    else
      @object_name.to_s.humanize
    end
    I18n.t(:"simple_form.buttons.#{key}", :model => model, :default => "#{key.to_s.humanize} #{model}")
  end
  options[:class] = "#{key} #{options[:class]}".strip
  @template.send(:"#{type}_tag", value, options)
end

def default_input_type #:nodoc:
  return @options[:as].to_sym if @options[:as]
  return :select              if @options[:collection]
  input_type = @column.try(:type)
  case input_type
    when :timestamp
      :datetime
    when :string, nil
      match = case @attribute_name.to_s
        when /password/  then :password
        when /time_zone/ then :time_zone
        when /country/   then :country
      end
      match || input_type || file_method? || :string
    else
      input_type
  end
end

def define_simple_form_attributes(attribute_name, options) #:nodoc:
  @options = options
  if @attribute_name = attribute_name
    @column     = find_attribute_column
    @input_type = default_input_type
  end
end

def error(attribute_name, options={})
  define_simple_form_attributes(attribute_name, :error_html => options)
  SimpleForm::Inputs::Base.new(self).error
end

def file_method? #:nodoc:
  file = @object.send(@attribute_name) if @object.respond_to?(@attribute_name)
  :file if file && SimpleForm.file_methods.any? { |m| file.respond_to?(m) }
end

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

def find_attribute_column #:nodoc:
  @object.column_for_attribute(@attribute_name) if @object.respond_to?(:column_for_attribute)
end

def hint(attribute_name, options={})
  attribute_name, options[:hint] = nil, attribute_name if attribute_name.is_a?(String)
  define_simple_form_attributes(attribute_name, :hint => options.delete(:hint), :hint_html => options)
  SimpleForm::Inputs::Base.new(self).hint
end

def input(attribute_name, options={}, &block)
  define_simple_form_attributes(attribute_name, options)
  if block_given?
    SimpleForm::Inputs::BlockInput.new(self, block).render
  else
    klass = self.class.mappings[input_type] ||
      self.class.const_get(:"#{input_type.to_s.camelize}Input")
    klass.new(self).render
  end
end

def label(attribute_name, *args)
  return super if args.first.is_a?(String)
  options = args.extract_options!
  define_simple_form_attributes(attribute_name, :label => options.delete(:label),
    :label_html => options, :required => options.delete(:required))
  SimpleForm::Inputs::Base.new(self).label
end