module ActiveFedora::AutosaveAssociation

def associated_records_to_validate_or_save(association, new_record, autosave)
  if new_record
    association&.target
  elsif autosave
    association.target.find_all(&:changed_for_autosave?)
  else
    association.target.find_all(&:new_record?)
  end
end

def association_valid?(reflection, record)
  return true if record.destroyed? || record.marked_for_destruction?
  unless valid = record.valid?
    if reflection.options[:autosave]
      record.errors.messages.each do |attribute, messages|
        attribute = "#{reflection.name}.#{attribute}"
        messages.map { |message| errors.add(attribute, message: message) }
      end
    else
      errors.add(reflection.name)
    end
  end
  valid
end

def before_save_collection_association
  @new_record_before_save = new_record?
  true
end

def changed_for_autosave?
  new_record? || changed? || marked_for_destruction? || nested_records_changed_for_autosave?
end

def destroyed_by_association
  @destroyed_by_association
end

def destroyed_by_association=(reflection)
  @destroyed_by_association = reflection
end

def mark_for_destruction
  @marked_for_destruction = true
end

def marked_for_destruction?
  @marked_for_destruction
end

def nested_records_changed_for_autosave?
  self.class.reflect_on_all_autosave_associations.any? do |reflection|
    association = association_instance_get(reflection.name)
    association && Array(association.target).any?(&:changed_for_autosave?)
  end
end

def reload
  @marked_for_destruction = false
  @destroyed_by_association = nil
  super
end

def save_belongs_to_association(reflection)
  association = association_instance_get(reflection.name)
  record      = association&.load_target
  if record && !record.destroyed?
    autosave = reflection.options[:autosave]
    if autosave && record.marked_for_destruction?
      record.destroy
    elsif autosave != false
      saved = record.save(validate: !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)
      if association.updated?
        self[reflection.foreign_key] = record.id
        association.loaded!
      end
      saved if autosave
    end
  end
end

def save_collection_association(reflection)
  if association = association_instance_get(reflection.name)
    autosave = reflection.options[:autosave]
    if records = associated_records_to_validate_or_save(association, @new_record_before_save, autosave)
      records.each do |record|
        next if record.destroyed?
        saved = true
        if autosave && record.marked_for_destruction?
          association.proxy.destroy(record)
        elsif autosave != false && (@new_record_before_save || record.new_record?)
          if autosave
            saved = association.insert_record(record, false)
          else
            association.insert_record(record)
          end
        elsif autosave
          saved = record.save(validate: false)
        end
        raise ActiveFedora::Rollback unless saved
      end
    end
    # reconstruct the scope now that we know the owner's id
    association.send(:reset_scope) if association.respond_to?(:reset_scope)
  end
end

def validate_collection_association(reflection)
  if association = association_instance_get(reflection.name)
    if records = associated_records_to_validate_or_save(association, new_record?, reflection.options[:autosave])
      records.each { |record| association_valid?(reflection, record) }
    end
  end
end

def validate_single_association(reflection)
  association = association_instance_get(reflection.name)
  record      = association&.target
  association_valid?(reflection, record) if record
end