module ActiveRecord::FinderMethods

def fifth
  find_nth 4
end

def fifth!
  fifth || raise_record_not_found_exception!
end

def find(*args)
  return super if block_given?
  find_with_ids(*args)
end

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

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

def find_last(limit)
  limit ? records.last(limit) : records.last
end

def find_nth(index)
  @offsets ||= {}
  @offsets[index] ||= find_nth_with_limit(index, 1).first
end

def find_nth_from_last(index)
  if loaded?
    records[-index]
  else
    relation = ordered_relation
    if equal?(relation) || has_limit_or_offset?
      relation.records[-index]
    else
      relation.last(index)[-index]
    end
  end
end

def find_nth_with_limit(index, limit)
  if loaded?
    records[index, limit] || []
  else
    relation = ordered_relation
    if limit_value
      limit = [limit_value - index, limit].min
    end
    if limit > 0
      relation = relation.offset((offset_value || 0) + index) unless index.zero?
      relation.limit(limit).to_a
    else
      []
    end
  end
end

def find_one(id)
  if ActiveRecord::Base === id
    raise ArgumentError, <<-MSG.squish
      You are passing an instance of ActiveRecord::Base to `find`.
      Please pass the id of the object by calling `.id`.
    MSG
  end
  relation = where(primary_key => id)
  record = relation.take
  raise_record_not_found_exception!(id, 0, 1) unless record
  record
end

def find_sole_by(arg, *args)
  where(arg, *args).sole
end

def find_some(ids)
  return find_some_ordered(ids) unless order_values.present?
  result = where(primary_key => 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_some_ordered(ids)
  ids = ids.slice(offset_value || 0, limit_value || ids.size) || []
  result = except(:limit, :offset).where(primary_key => ids).records
  if result.size == ids.size
    result.in_order_of(:id, ids.map { |id| @klass.type_for_attribute(primary_key).cast(id) })
  else
    raise_record_not_found_exception!(ids, result.size, ids.size)
  end
end

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

def find_take_with_limit(limit)
  if loaded?
    records.take(limit)
  else
    limit(limit).to_a
  end
end

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

def first(limit = nil)
  if limit
    find_nth_with_limit(0, limit)
  else
    find_nth 0
  end
end

def first!
  first || raise_record_not_found_exception!
end

def forty_two
  find_nth 41
end

def forty_two!
  forty_two || raise_record_not_found_exception!
end

def fourth
  find_nth 3
end

def fourth!
  fourth || raise_record_not_found_exception!
end

def include?(record)
  if loaded? || offset_value || limit_value || having_clause.any?
    records.include?(record)
  else
    record.is_a?(klass) && exists?(record.id)
  end
end

def last(limit = nil)
  return find_last(limit) if loaded? || has_limit_or_offset?
  result = ordered_relation.limit(limit)
  result = result.reverse_order!
  limit ? result.reverse : result.first
end

def last!
  last || raise_record_not_found_exception!
end

def ordered_relation
  if order_values.empty? && (implicit_order_column || primary_key)
    if implicit_order_column && primary_key && implicit_order_column != primary_key
      order(table[implicit_order_column].asc, table[primary_key].asc)
    else
      order(table[implicit_order_column || primary_key].asc)
    end
  else
    self
  end
end

def raise_record_not_found_exception!(ids = nil, result_size = nil, expected_size = nil, key = primary_key, not_found_ids = nil) # :nodoc:
  conditions = " [#{arel.where_sql(klass)}]" unless where_clause.empty?
  name = @klass.name
  if ids.nil?
    error = +"Couldn't find #{name}"
    error << " with#{conditions}" if conditions
    raise RecordNotFound.new(error, name, key)
  elsif Array.wrap(ids).size == 1
    error = "Couldn't find #{name} with '#{key}'=#{ids}#{conditions}"
    raise RecordNotFound.new(error, name, key, ids)
  else
    error = +"Couldn't find all #{name.pluralize} with '#{key}': "
    error << "(#{ids.join(", ")})#{conditions} (found #{result_size} results, but was looking for #{expected_size})."
    error << " Couldn't find #{name.pluralize(not_found_ids.size)} with #{key.to_s.pluralize(not_found_ids.size)} #{not_found_ids.join(', ')}." if not_found_ids
    raise RecordNotFound.new(error, name, key, ids)
  end
end

def second
  find_nth 1
end

def second!
  second || raise_record_not_found_exception!
end

def second_to_last
  find_nth_from_last 2
end

def second_to_last!
  second_to_last || raise_record_not_found_exception!
end

def sole
  found, undesired = first(2)
  if found.nil?
    raise_record_not_found_exception!
  elsif undesired.present?
    raise ActiveRecord::SoleRecordExceeded.new(self)
  else
    found
  end
end

def take(limit = nil)
  limit ? find_take_with_limit(limit) : find_take
end

def take!
  take || raise_record_not_found_exception!
end

def third
  find_nth 2
end

def third!
  third || raise_record_not_found_exception!
end

def third_to_last
  find_nth_from_last 3
end

def third_to_last!
  third_to_last || raise_record_not_found_exception!
end

def using_limitable_reflections?(reflections)
  reflections.none?(&:collection?)
end