module ActiveRecord::FinderMethods

def find(*args)
  if block_given?
    to_a.find { |*block_args| yield(*block_args) }
  else
    find_with_ids(*args)
  end
end

def find_by(*args)
  where(*args).take
end

def find_by!(*args)
  where(*args).take!
end

def find_first
  if loaded?
    @records.first
  else
    @first ||= find_first_with_limit(1).first
  end
end

def find_first_with_limit(limit)
  if order_values.empty? && primary_key
    order(arel_table[primary_key].asc).limit(limit).to_a
  else
    limit(limit).to_a
  end
end

def find_last
  if loaded?
    @records.last
  else
    @last ||=
      if limit_value
        to_a.last
      else
        reverse_order.limit(1).to_a.first
      end
  end
end

def find_one(id)
  id = id.id if ActiveRecord::Base === id
  column = columns_hash[primary_key]
  substitute = connection.substitute_at(column, bind_values.length)
  relation = where(table[primary_key].eq(substitute))
  relation.bind_values += [[column, id]]
  record = relation.take
  raise_record_not_found_exception!(id, 0, 1) unless record
  record
end

def find_some(ids)
  result = where(table[primary_key].in(ids)).to_a
  expected_size =
    if limit_value && ids.size > limit_value
      limit_value
    else
      ids.size
    end
  # 11 ids with limit 3, offset 9 should give 2 results.
  if offset_value && (ids.size - offset_value < expected_size)
    expected_size = ids.size - offset_value
  end
  if result.size == expected_size
    result
  else
    raise_record_not_found_exception!(ids, result.size, expected_size)
  end
end

def find_take
  if loaded?
    @records.first
  else
    @take ||= limit(1).to_a.first
  end
end

def find_with_associations
  join_dependency = construct_join_dependency
  aliases  = join_dependency.aliases
  relation = select aliases.columns
  relation = apply_join_dependency(relation, join_dependency)
  if block_given?
    yield relation
  else
    if ActiveRecord::NullRelation === relation
      []
    else
      rows = connection.select_all(relation.arel, 'SQL', relation.bind_values.dup)
      join_dependency.instantiate(rows, aliases)
    end
  end
end

def find_with_ids(*ids)
  raise UnknownPrimaryKey.new(@klass) if primary_key.nil?
  expects_array = ids.first.kind_of?(Array)
  return ids.first if expects_array && ids.first.empty?
  ids = ids.flatten.compact.uniq
  case ids.size
  when 0
    raise RecordNotFound, "Couldn't find #{@klass.name} without an ID"
  when 1
    result = find_one(ids.first)
    expects_array ? [ result ] : result
  else
    find_some(ids)
  end
end

def first(limit = nil)
  if limit
    find_first_with_limit(limit)
  else
    find_first
  end
end

def first!
  first or raise RecordNotFound
end

def last(limit = nil)
  if limit
    if order_values.empty? && primary_key
      order(arel_table[primary_key].desc).limit(limit).reverse
    else
      to_a.last(limit)
    end
  else
    find_last
  end
end

def last!
  last or raise RecordNotFound
end

def limited_ids_for(relation)
  values = @klass.connection.columns_for_distinct(
    "#{quoted_table_name}.#{quoted_primary_key}", relation.order_values)
  relation = relation.except(:select).select(values).distinct!
  id_rows = @klass.connection.select_all(relation.arel, 'SQL', relation.bind_values)
  id_rows.map {|row| row[primary_key]}
end

def raise_record_not_found_exception!(ids, result_size, expected_size) #:nodoc:
  conditions = arel.where_sql
  conditions = " [#{conditions}]" if conditions
  if Array(ids).size == 1
    error = "Couldn't find #{@klass.name} with #{primary_key}=#{ids}#{conditions}"
  else
    error = "Couldn't find all #{@klass.name.pluralize} with IDs "
    error << "(#{ids.join(", ")})#{conditions} (found #{result_size} results, but was looking for #{expected_size})"
  end
  raise RecordNotFound, error
end

def take(limit = nil)
  limit ? limit(limit).to_a : find_take
end

def take!
  take or raise RecordNotFound
end

def using_limitable_reflections?(reflections)
  reflections.none? { |r| r.collection? }
end