module Mongoid::Threaded

def autosaved?(document)
  autosaves_for(document.class).include?(document._id)
end

def autosaves
  Thread.current[AUTOSAVES_KEY] ||= {}
end

def autosaves_for(klass)
  autosaves[klass] ||= []
end

def begin_autosave(document)
  autosaves_for(document.class).push(document._id)
end

def begin_execution(name)
  stack(name).push(true)
end

def begin_validate(document)
  validations_for(document.class).push(document._id)
end

def begin_without_default_scope(klass)
  stack(:without_default_scope).push(klass)
end

def clear_session
  session = get_session
  session.end_session if session
  Thread.current["[mongoid]:session"] = nil
end

def client_override
  Thread.current[CLIENT_OVERRIDE_KEY]
end

def client_override=(name)
  Thread.current[CLIENT_OVERRIDE_KEY] = name
end

def current_scope(klass = nil)
  if klass && Thread.current[CURRENT_SCOPE_KEY].respond_to?(:keys)
    Thread.current[CURRENT_SCOPE_KEY][
        Thread.current[CURRENT_SCOPE_KEY].keys.find { |k| k <= klass }
    ]
  else
    Thread.current[CURRENT_SCOPE_KEY]
  end
end

def current_scope=(scope)
  Thread.current[CURRENT_SCOPE_KEY] = scope
end

def database_override
  Thread.current[DATABASE_OVERRIDE_KEY]
end

def database_override=(name)
  Thread.current[DATABASE_OVERRIDE_KEY] = name
end

def execute_callbacks=(flag)
  Thread.current[EXECUTE_CALLBACKS] = flag
end

def execute_callbacks?
  if Thread.current.key?(EXECUTE_CALLBACKS)
    Thread.current[EXECUTE_CALLBACKS]
  else
    true
  end
end

def executing?(name)
  !stack(name).empty?
end

def exit_autosave(document)
  autosaves_for(document.class).delete_one(document._id)
end

def exit_execution(name)
  stack(name).pop
end

def exit_validate(document)
  validations_for(document.class).delete_one(document._id)
end

def exit_without_default_scope(klass)
  stack(:without_default_scope).delete(klass)
end

def get_session
  Thread.current["[mongoid]:session"]
end

def set_current_scope(scope, klass)
  if scope.nil?
    if Thread.current[CURRENT_SCOPE_KEY]
      Thread.current[CURRENT_SCOPE_KEY].delete(klass)
      Thread.current[CURRENT_SCOPE_KEY] = nil if Thread.current[CURRENT_SCOPE_KEY].empty?
    end
  else
    Thread.current[CURRENT_SCOPE_KEY] ||= {}
    Thread.current[CURRENT_SCOPE_KEY][klass] = scope
  end
end

def set_session(session)
  Thread.current["[mongoid]:session"] = session
end

def stack(name)
  Thread.current[STACK_KEYS[name]] ||= []
end

def validated?(document)
  validations_for(document.class).include?(document._id)
end

def validations
  Thread.current[VALIDATIONS_KEY] ||= {}
end

def validations_for(klass)
  validations[klass] ||= []
end

def without_default_scope?(klass)
  stack(:without_default_scope).include?(klass)
end