module ActiveRecord::Persistence

def _create_record(attribute_names = self.attribute_names)
  attribute_names = attributes_for_create(attribute_names)
  new_id = self.class._insert_record(
    attributes_with_values(attribute_names)
  )
  self.id ||= new_id if @primary_key
  @new_record = false
  @previously_new_record = true
  yield(self) if block_given?
  id
end

def _delete_row
  self.class._delete_record(_query_constraints_hash)
end

def _find_record(options)
  if options && options[:lock]
    self.class.preload(strict_loaded_associations).lock(options[:lock]).find(id)
  else
    self.class.preload(strict_loaded_associations).find(id)
  end
end

def _query_constraints_hash
  { @primary_key => id_in_database }
end

def _raise_readonly_record_error
  raise ReadOnlyRecord, "#{self.class} is marked as readonly"
end

def _raise_record_not_destroyed
  @_association_destroy_exception ||= nil
  key = self.class.primary_key
  raise @_association_destroy_exception || RecordNotDestroyed.new("Failed to destroy #{self.class} with #{key}=#{send(key)}", self)
ensure
  @_association_destroy_exception = nil
end

def _raise_record_not_touched_error
  raise ActiveRecordError, <<~MSG.squish
    Cannot touch on a new or destroyed record object. Consider using
    persisted?, new_record?, or destroyed? before touching.
  MSG
end

def _touch_row(attribute_names, time)
  time ||= current_time_from_proper_timezone
  attribute_names.each do |attr_name|
    _write_attribute(attr_name, time)
  end
  _update_row(attribute_names, "touch")
end

def _update_record(attribute_names = self.attribute_names)
  attribute_names = attributes_for_update(attribute_names)
  if attribute_names.empty?
    affected_rows = 0
    @_trigger_update_callback = true
  else
    affected_rows = _update_row(attribute_names)
    @_trigger_update_callback = affected_rows == 1
  end
  @previously_new_record = false
  yield(self) if block_given?
  affected_rows
end

def _update_row(attribute_names, attempted_action = "update")
  self.class._update_record(
    attributes_with_values(attribute_names),
    _query_constraints_hash
  )
end

def apply_scoping?(options)
  !(options && options[:unscoped]) &&
    (self.class.default_scopes?(all_queries: true) || self.class.global_current_scope)
end

def becomes(klass)
  became = klass.allocate
  became.send(:initialize) do |becoming|
    becoming.instance_variable_set(:@attributes, @attributes)
    becoming.instance_variable_set(:@mutations_from_database, @mutations_from_database ||= nil)
    becoming.instance_variable_set(:@new_record, new_record?)
    becoming.instance_variable_set(:@destroyed, destroyed?)
    becoming.errors.copy!(errors)
  end
  became
end

def becomes!(klass)
  became = becomes(klass)
  sti_type = nil
  if !klass.descends_from_active_record?
    sti_type = klass.sti_name
  end
  became.public_send("#{klass.inheritance_column}=", sti_type)
  became
end

def belongs_to_touch_method
  :touch
end

def create_or_update(**, &block)
  _raise_readonly_record_error if readonly?
  return false if destroyed?
  result = new_record? ? _create_record(&block) : _update_record(&block)
  result != false
end

def decrement(attribute, by = 1)
  increment(attribute, -by)
end

def decrement!(attribute, by = 1, touch: nil)
  increment!(attribute, -by, touch: touch)
end

def delete
  _delete_row if persisted?
  @destroyed = true
  @previously_new_record = false
  freeze
end

def destroy
  _raise_readonly_record_error if readonly?
  destroy_associations
  @_trigger_destroy_callback = if persisted?
    destroy_row > 0
  else
    true
  end
  @destroyed = true
  @previously_new_record = false
  freeze
end

def destroy!
  destroy || _raise_record_not_destroyed
end

def destroy_associations
end

def destroy_row
  _delete_row
end

def destroyed?
  @destroyed
end

def increment(attribute, by = 1)
  self[attribute] ||= 0
  self[attribute] += by
  self
end

def increment!(attribute, by = 1, touch: nil)
  increment(attribute, by)
  change = public_send(attribute) - (public_send(:"#{attribute}_in_database") || 0)
  self.class.update_counters(id, attribute => change, touch: touch)
  public_send(:"clear_#{attribute}_change")
  self
end

def new_record?
  @new_record
end

def persisted?
  !(@new_record || @destroyed)
end

def previously_new_record?
  @previously_new_record
end

def previously_persisted?
  !new_record? && destroyed?
end

def reload(options = nil)
  self.class.connection.clear_query_cache
  fresh_object = if apply_scoping?(options)
    _find_record(options)
  else
    self.class.unscoped { _find_record(options) }
  end
  @association_cache = fresh_object.instance_variable_get(:@association_cache)
  @attributes = fresh_object.instance_variable_get(:@attributes)
  @new_record = false
  @previously_new_record = false
  self
end

def save(**options, &block)
  create_or_update(**options, &block)
rescue ActiveRecord::RecordInvalid
  false
end

def save!(**options, &block)
  create_or_update(**options, &block) || raise(RecordNotSaved.new("Failed to save the record", self))
end

def strict_loaded_associations
  @association_cache.find_all do |_, assoc|
    assoc.owner.strict_loading? && !assoc.owner.strict_loading_n_plus_one_only?
  end.map(&:first)
end

def toggle(attribute)
  self[attribute] = !public_send("#{attribute}?")
  self
end

def toggle!(attribute)
  toggle(attribute).update_attribute(attribute, self[attribute])
end

def touch(*names, time: nil)
  _raise_record_not_touched_error unless persisted?
  _raise_readonly_record_error if readonly?
  attribute_names = timestamp_attributes_for_update_in_model
  attribute_names |= names.map! do |name|
    name = name.to_s
    self.class.attribute_aliases[name] || name
  end unless names.empty?
  unless attribute_names.empty?
    affected_rows = _touch_row(attribute_names, time)
    @_trigger_update_callback = affected_rows == 1
  else
    true
  end
end

def update(attributes)
  # The following transaction covers any possible database side-effects of the
  # attributes assignment. For example, setting the IDs of a child collection.
  with_transaction_returning_status do
    assign_attributes(attributes)
    save
  end
end

def update!(attributes)
  # The following transaction covers any possible database side-effects of the
  # attributes assignment. For example, setting the IDs of a child collection.
  with_transaction_returning_status do
    assign_attributes(attributes)
    save!
  end
end

def update_attribute(name, value)
  name = name.to_s
  verify_readonly_attribute(name)
  public_send("#{name}=", value)
  save(validate: false)
end

def update_column(name, value)
  update_columns(name => value)
end

def update_columns(attributes)
  raise ActiveRecordError, "cannot update a new record" if new_record?
  raise ActiveRecordError, "cannot update a destroyed record" if destroyed?
  _raise_readonly_record_error if readonly?
  attributes = attributes.transform_keys do |key|
    name = key.to_s
    name = self.class.attribute_aliases[name] || name
    verify_readonly_attribute(name) || name
  end
  update_constraints = _query_constraints_hash
  attributes = attributes.each_with_object({}) do |(k, v), h|
    h[k] = @attributes.write_cast_value(k, v)
    clear_attribute_change(k)
  end
  affected_rows = self.class._update_record(
    attributes,
    update_constraints
  )
  affected_rows == 1
end

def verify_readonly_attribute(name)
  raise ActiveRecordError, "#{name} is marked as readonly" if self.class.readonly_attribute?(name)
end