class ActiveFedora::Associations::CollectionAssociation

def ensure_owner_is_not_new
  if @owner.new_record?
    raise ActiveFedora::RecordNotSaved, "You cannot call create unless the parent is saved"
  end
end

def find(*args)
  scope.find(*args)
end

def find_reflection
  return reflection if @reflection.options[:predicate]
  if @reflection.class_name && @reflection.class_name != 'ActiveFedora::Base' && @reflection.macro != :has_and_belongs_to_many
    @reflection.inverse_of || raise("No :inverse_of or :predicate attribute was set or could be inferred for #{@reflection.macro} #{@reflection.name.inspect} on #{@owner.class}")
  else
    raise "Couldn't find reflection"
  end
end

def find_target
  # TODO: don't reify, just store the solr results and lazily reify.
  # For now, we set a hard limit of 1000 results.
  records = ActiveFedora::QueryResultBuilder.reify_solr_results(load_from_solr(rows: 1000))
  records.each { |record| set_inverse_instance(record) }
  records
end

def first(*args)
  first_or_last(:first, *args)
end

def first_or_last(type, *args)
  args.shift if args.first.is_a?(Hash) && args.first.empty?
  #collection = fetch_first_or_last_using_find?(args) ? scoped : load_target
  collection = load_target
  collection.send(type, *args).tap do |record|
    set_inverse_instance record if record.is_a? ActiveFedora::Base
  end
end

def ids_reader
  if loaded?
    load_target.map do |record|
      record.id
    end
  else
    load_from_solr.map do |solr_record|
      solr_record['id']
    end
  end
end

def ids_writer(ids)
  ids = Array(ids).reject { |id| id.blank? }
  replace(klass.find(ids))#.index_by { |r| r.id }.values_at(*ids))
  #TODO, like this when find() can return multiple records
  #send("#{reflection.name}=", reflection.klass.find(ids))
  #send("#{reflection.name}=", ids.collect { |id| reflection.klass.find(id)})
end

def include?(record)
  if record.is_a?(reflection.klass)
    if record.new_record?
      target.include?(record)
    else
      loaded? ? target.include?(record) : scope.exists?(record)
    end
  else
    false
  end
end

def initialize(owner, reflection)
  super
  construct_query
end

def last(*args)
  first_or_last(:last, *args)
end

def load_from_solr(opts = Hash.new)
  return [] if @finder_query.empty?
  rows = opts.delete(:rows) { count }
  return [] if rows == 0
  SolrService.query(@finder_query, {rows: rows}.merge(opts))
end

def load_target
  if find_target?
    targets = []
    begin
      targets = find_target
    rescue ObjectNotFoundError, Ldp::Gone => e
      ActiveFedora::Base.logger.error "Solr and Fedora may be out of sync:\n" + e.message if ActiveFedora::Base.logger
      reset
    end
    @target = merge_target_lists(targets, @target)
  end
  loaded!
  target
end

def merge_target_lists(loaded, existing)
  return loaded if existing.empty?
  return existing if loaded.empty?
  loaded.map do |f|
    i = existing.index(f)
    if i
      existing.delete_at(i).tap do |t|
        keys = ["id"] + t.changes.keys + (f.attribute_names - t.attribute_names)
        # FIXME: this call to attributes causes many NoMethodErrors
        attributes = f.attributes
        (attributes.keys - keys).each do |k|
          t.send("#{k}=", attributes[k])
        end
      end
    else
      f
    end
  end + existing
end

def null_scope?
  owner.new_record? && !foreign_key_present?
end

def reader(opts = false)
  if opts.kind_of?(Hash)
    if opts.delete(:response_format) == :solr
      return load_from_solr(opts)
    end
    raise ArgumentError, "Hash parameter must include :response_format=>:solr (#{opts.inspect})"
  else
    force_reload = opts
  end
  reload if force_reload || stale_target?
  @proxy ||= CollectionProxy.new(self)
end

def replace(other_array)
  other_array.each { |val| raise_on_type_mismatch(val) }
  load_target
  other   = other_array.size < 100 ? other_array : other_array.to_set
  current = @target.size < 100 ? @target : @target.to_set
  delete(@target.select { |v| !other.include?(v) })
  concat(other_array.select { |v| !current.include?(v) })
end

def reset
  reset_target!
  @loaded = false
end

def reset_target!
  @target = Array.new
end

def scope(opts = {})
  scope = super()
  scope.none! if opts.fetch(:nullify, true) && null_scope?
  scope
end

def size
  if @owner.new_record? && @target
    @target.size
  elsif !loaded? && @target.is_a?(Array)
    unsaved_records = @target.select { |r| r.new_record? }
    unsaved_records.size + count_records
  else
    count_records
  end
end

def target=(target)
  @target = [target]
  loaded!
end

def to_ary
  load_target.dup
end

def writer(records)
  replace(records)
end