module Mongoid::Persistable::Creatable

def atomic_inserts
  { atomic_insert_modifier => { atomic_position => as_attributes }}
end

def insert(options = {})
  prepare_insert(options) do
    if embedded?
      insert_as_embedded
    else
      insert_as_root
    end
  end
end

def insert_as_embedded
  raise Errors::NoParent.new(self.class.name) unless _parent
  if _parent.new_record?
    _parent.insert
  else
    selector = _parent.atomic_selector
    _root.collection.find(selector).update_one(
        positionally(selector, atomic_inserts),
        session: _session)
  end
end

def insert_as_root
  collection.insert_one(as_attributes, session: _session)
end

def post_process_insert
  self.new_record = false
  remember_storage_options!
  flag_descendants_persisted
  true
end

def prepare_insert(options = {})
  raise Errors::ReadonlyDocument.new(self.class) if readonly? && !Mongoid.legacy_readonly
  return self if performing_validations?(options) &&
    invalid?(options[:context] || :create)
  ensure_client_compatibility!
  run_callbacks(:commit, with_children: true, skip_if: -> { in_transaction? }) do
    run_callbacks(:save, with_children: false) do
      run_callbacks(:create, with_children: false) do
        run_callbacks(:persist_parent, with_children: false) do
          _mongoid_run_child_callbacks(:save) do
            _mongoid_run_child_callbacks(:create) do
              result = yield(self)
              if !result.is_a?(Document) || result.errors.empty?
                post_process_insert
                post_process_persist(result, options)
              end
            end
          end
        end
      end
    end
  end
  self
end