class ActiveRecord::Reflection::AbstractReflection

def actual_source_reflection # FIXME: this is a horrible name
  self
end

def alias_candidate(name)
  "#{plural_name}_#{name}"
end

def build_association(attributes, &block)
  klass.new(attributes, &block)
end

def build_scope(table, predicate_builder = predicate_builder(table), klass = self.klass)
  Relation.create(
    klass,
    table: table,
    predicate_builder: predicate_builder
  )
end

def chain
  collect_join_chain
end

def check_validity_of_inverse!
  unless polymorphic?
    if has_inverse? && inverse_of.nil?
      raise InverseOfAssociationNotFoundError.new(self)
    end
    if has_inverse? && inverse_of == self
      raise InverseOfAssociationRecursiveError.new(self)
    end
  end
end

def class_name
  @class_name ||= -(options[:class_name] || derive_class_name).to_s
end

def constraints
  chain.flat_map(&:scopes)
end

def counter_cache_column
  @counter_cache_column ||= if belongs_to?
    if options[:counter_cache] == true
      -"#{active_record.name.demodulize.underscore.pluralize}_count"
    elsif options[:counter_cache]
      -options[:counter_cache].to_s
    end
  else
    -(options[:counter_cache]&.to_s || "#{name}_count")
  end
end

def counter_must_be_updated_by_has_many?
  !inverse_updates_counter_in_memory? && has_cached_counter?
end

def ensure_option_not_given_as_class!(option_name)
  if options[option_name] && options[option_name].class == Class
    raise ArgumentError, "A class was passed to `:#{option_name}` but we are expecting a string."
  end
end

def has_cached_counter?
  options[:counter_cache] ||
    inverse_which_updates_counter_cache && inverse_which_updates_counter_cache.options[:counter_cache] &&
    active_record.has_attribute?(counter_cache_column)
end

def inverse_of
  return unless inverse_name
  @inverse_of ||= klass._reflect_on_association inverse_name
end

def inverse_updates_counter_in_memory?
  inverse_of && inverse_which_updates_counter_cache == inverse_of
end

def inverse_which_updates_counter_cache
  return @inverse_which_updates_counter_cache if defined?(@inverse_which_updates_counter_cache)
  @inverse_which_updates_counter_cache = klass.reflect_on_all_associations(:belongs_to).find do |inverse|
    inverse.counter_cache_column == counter_cache_column
  end
end

def join_scope(table, foreign_table, foreign_klass)
  predicate_builder = predicate_builder(table)
  scope_chain_items = join_scopes(table, predicate_builder)
  klass_scope       = klass_join_scope(table, predicate_builder)
  if type
    klass_scope.where!(type => foreign_klass.polymorphic_name)
  end
  scope_chain_items.inject(klass_scope, &:merge!)
  primary_key = join_primary_key
  foreign_key = join_foreign_key
  klass_scope.where!(table[primary_key].eq(foreign_table[foreign_key]))
  if klass.finder_needs_type_condition?
    klass_scope.where!(klass.send(:type_condition, table))
  end
  klass_scope
end

def join_scopes(table, predicate_builder, klass = self.klass, record = nil) # :nodoc:
  if scope
    [scope_for(build_scope(table, predicate_builder, klass), record)]
  else
    []
  end
end

def klass_join_scope(table, predicate_builder) # :nodoc:
  relation = build_scope(table, predicate_builder)
  klass.scope_for_association(relation)
end

def predicate_builder(table)
  PredicateBuilder.new(TableMetadata.new(klass, table))
end

def primary_key(klass)
  klass.primary_key || raise(UnknownPrimaryKey.new(klass))
end

def scopes
  scope ? [scope] : []
end

def strict_loading?
  options[:strict_loading]
end

def strict_loading_violation_message(owner)
  message = +"`#{owner}` is marked for strict_loading."
  message << " The #{polymorphic? ? "polymorphic association" : "#{klass} association"}"
  message << " named `:#{name}` cannot be lazily loaded."
end

def table_name
  klass.table_name
end

def through_reflection?
  false
end