class ActiveFedora::Associations::IndirectlyContainsAssociation

def build_proxy_node(attributes, &block)
  proxy_class.new({ id: container.mint_id }.merge(attributes), &block)
end

def composite_proxy_repository
  RecordComposite::Repository.new(base_repository: proxy_class)
end

def concat(*records)
  concat_records(records)
end

def container
  @container ||= begin
    IndirectContainer.find_or_initialize(ActiveFedora::Base.uri_to_id(uri)).tap do |container|
      container.parent = @owner
      container.has_member_relation = Array(options[:has_member_relation])
      container.is_member_of_relation = Array(options[:is_member_of_relation])
      container.inserted_content_relation = Array(options[:inserted_content_relation])
    end
  end
end

def delete_record(record)
  record_proxy_finder.find(record).delete
end

def delete_records(records, _method)
  container.reload # Reload container to get updated LDP.contains
  records.each do |record|
    delete_record(record)
  end
end

def find_target
  if container_predicate = options[:has_member_relation]
    uris = owner.resource.query(predicate: container_predicate).map { |r| r.object.to_s }
    uris.map { |object_uri| klass.find(klass.uri_to_id(object_uri)) }
  else # is_member_of_relation
    # TODO this is a lot of reads. Avoid this path
    container_predicate = ::RDF::Vocab::LDP.contains
    proxy_uris = container.resource.query(predicate: container_predicate).map { |r| r.object.to_s }
    proxy_uris.map { |uri| proxy_class.find(proxy_class.uri_to_id(uri))[options[:foreign_key]] }
  end
end

def ids_reader
  predicate = reflection.options.fetch(:has_member_relation)
  if loaded?
    target.map(&:id)
  else
    owner.resource.query(predicate: predicate)
         .map { |s| ActiveFedora::Base.uri_to_id(s.object) } | target.map(&:id)
  end
end

def initialize_attributes(_record) #:nodoc:
  # record.uri = ActiveFedora::Base.id_to_uri(container.mint_id)
  # set_inverse_instance(record)
end

def insert_record(record, force = true, validate = true)
  container.save!
  if force
    record.save!
  else
    return false unless record.save(validate: validate)
  end
  save_through_record(record)
  true
end

def proxy_class
  @proxy_class ||= options[:through].constantize
end

def record_proxy_finder
  ContainedFinder.new(container: container, repository: composite_proxy_repository, proxy_class: proxy_class)
end

def save_through_record(record)
  build_proxy_node({}) do |node|
    node[options[:foreign_key]] = record
    node.save
  end
end