class ActiveRecord::FixtureSet

def [](x)
  fixtures[x]
end

def []=(k, v)
  fixtures[k] = v
end

def cache_fixtures(connection, fixtures_map)
  cache_for_connection(connection).update(fixtures_map)
end

def cache_for_connection(connection)
  @@all_cached_fixtures[connection]
end

def cached_fixtures(connection, keys_to_fetch = nil)
  if keys_to_fetch
    cache_for_connection(connection).values_at(*keys_to_fetch)
  else
    cache_for_connection(connection).values
  end
end

def context_class
  @context_class ||= Class.new
end

def create_fixtures(fixtures_directory, fixture_set_names, class_names = {}, config = ActiveRecord::Base, &block)
  fixture_set_names = Array(fixture_set_names).map(&:to_s)
  class_names = ClassCache.new class_names, config
  # FIXME: Apparently JK uses this.
  connection = block_given? ? block : lambda { ActiveRecord::Base.connection }
  fixture_files_to_read = fixture_set_names.reject do |fs_name|
    fixture_is_cached?(connection.call, fs_name)
  end
  if fixture_files_to_read.any?
    fixtures_map = read_and_insert(
      fixtures_directory,
      fixture_files_to_read,
      class_names,
      connection,
    )
    cache_fixtures(connection.call, fixtures_map)
  end
  cached_fixtures(connection.call, fixture_set_names)
end

def default_fixture_model_name(fixture_set_name, config = ActiveRecord::Base) # :nodoc:
  config.pluralize_table_names ?
    fixture_set_name.singularize.camelize :
    fixture_set_name.camelize
end

def default_fixture_table_name(fixture_set_name, config = ActiveRecord::Base) # :nodoc:
  "#{ config.table_name_prefix }"\
  "#{ fixture_set_name.tr('/', '_') }"\
  "#{ config.table_name_suffix }".to_sym
end

def each(&block)
  fixtures.each(&block)
end

def fixture_is_cached?(connection, table_name)
  cache_for_connection(connection)[table_name]
end

def identify(label, column_type = :integer)
  if column_type == :uuid
    Digest::UUID.uuid_v5(Digest::UUID::OID_NAMESPACE, label.to_s)
  else
    Zlib.crc32(label.to_s) % MAX_ID
  end
end

def ignored_fixtures=(base)
  @ignored_fixtures =
      case base
      when Array
        base
      when String
        [base]
      else
        []
      end
  @ignored_fixtures << "DEFAULTS" unless @ignored_fixtures.include?("DEFAULTS")
  @ignored_fixtures.compact
end

def initialize(_, name, class_name, path, config = ActiveRecord::Base)
  @name     = name
  @path     = path
  @config   = config
  self.model_class = class_name
  @fixtures = read_fixture_files(path)
  @table_name = model_class&.table_name || self.class.default_fixture_table_name(name, config)
end

def insert(fixture_sets, connection) # :nodoc:
  fixture_sets_by_connection = fixture_sets.group_by do |fixture_set|
    if fixture_set.model_class
      fixture_set.model_class.connection
    else
      connection.call
    end
  end
  fixture_sets_by_connection.each do |conn, set|
    table_rows_for_connection = Hash.new { |h, k| h[k] = [] }
    set.each do |fixture_set|
      fixture_set.table_rows.each do |table, rows|
        table_rows_for_connection[table].unshift(*rows)
      end
    end
    conn.insert_fixtures_set(table_rows_for_connection, table_rows_for_connection.keys)
    if ActiveRecord.verify_foreign_keys_for_fixtures && !conn.all_foreign_keys_valid?
      raise "Foreign key violations found in your fixture data. Ensure you aren't referring to labels that don't exist on associations."
    end
    # Cap primary key sequences to max(pk).
    if conn.respond_to?(:reset_pk_sequence!)
      set.each { |fs| conn.reset_pk_sequence!(fs.table_name) }
    end
  end
end

def instantiate_all_loaded_fixtures(object, load_instances = true)
  all_loaded_fixtures.each_value do |fixture_set|
    instantiate_fixtures(object, fixture_set, load_instances)
  end
end

def instantiate_fixtures(object, fixture_set, load_instances = true)
  return unless load_instances
  fixture_set.each do |fixture_name, fixture|
    object.instance_variable_set "@#{fixture_name}", fixture.find
  rescue FixtureClassNotFound
    nil
  end
end

def model_class=(class_name)
  if class_name.is_a?(Class) # TODO: Should be an AR::Base type class, or any?
    @model_class = class_name
  else
    @model_class = class_name.safe_constantize if class_name
  end
end

def read_and_insert(fixtures_directory, fixture_files, class_names, connection) # :nodoc:
  fixtures_map = {}
  fixture_sets = fixture_files.map do |fixture_set_name|
    klass = class_names[fixture_set_name]
    fixtures_map[fixture_set_name] = new( # ActiveRecord::FixtureSet.new
      nil,
      fixture_set_name,
      klass,
      ::File.join(fixtures_directory, fixture_set_name)
    )
  end
  update_all_loaded_fixtures(fixtures_map)
  insert(fixture_sets, connection)
  fixtures_map
end

def read_fixture_files(path)
  yaml_files = Dir["#{path}/{**,*}/*.yml"].select { |f|
    ::File.file?(f)
  } + [yaml_file_path(path)]
  yaml_files.each_with_object({}) do |file, fixtures|
    FixtureSet::File.open(file) do |fh|
      self.model_class ||= fh.model_class if fh.model_class
      self.ignored_fixtures ||= fh.ignored_fixtures
      fh.each do |fixture_name, row|
        fixtures[fixture_name] = ActiveRecord::Fixture.new(row, model_class)
      end
    end
  end
end

def reset_cache
  @@all_cached_fixtures.clear
end

def size
  fixtures.size
end

def table_rows
  # allow specifying fixtures to be ignored by setting `ignore` in `_fixture` section
  fixtures.except!(*ignored_fixtures)
  TableRows.new(
    table_name,
    model_class: model_class,
    fixtures: fixtures,
  ).to_hash
end

def update_all_loaded_fixtures(fixtures_map) # :nodoc:
  all_loaded_fixtures.update(fixtures_map)
end

def yaml_file_path(path)
  "#{path}.yml"
end