class Mongoid::PersistenceContext

def ==(other)
  return false unless other.is_a?(PersistenceContext)
  options == other.options
end

def __evaluate__(name)
  return nil unless name
  name.respond_to?(:call) ? name.call.to_sym : name.to_sym
end

def clear(object, cluster = nil, original_context = nil)
  if context = get(object)
    unless cluster.nil? || context.cluster.equal?(cluster)
      context.client.close unless context.reusable_client?
    end
  end
ensure
  store_context(object, original_context)
end

def client
  @client ||= begin
    client = Clients.with_name(client_name)
    options = client_options
    if database_name_option
      client = client.use(database_name)
      options = options.except(:database, 'database')
    end
    client = client.with(options) unless options.empty?
    client
  end
end

def client_name
  @client_name ||= __evaluate__(options[:client]) ||
                     Threaded.client_override ||
                     __evaluate__(storage_options[:client])
end

def client_options
  @client_options ||= begin
    opts = options.select do |k, v|
                          Mongo::Client::VALID_OPTIONS.include?(k.to_sym)
                        end
    if opts[:read].is_a?(Symbol)
      opts[:read] = {mode: opts[:read]}
    end
    opts
  end
end

def collection(parent = nil)
  parent ?
    parent.collection.with(client_options.except(:database, "database")) :
    client[collection_name.to_sym]
end

def collection_name
  @collection_name ||= (__evaluate__(options[:collection] ||
                         storage_options[:collection]))
end

def context_store
  Threaded.get(PERSISTENCE_CONTEXT_KEY) { {} }
end

def database_name
  __evaluate__(database_name_option) || client.database.name
end

def database_name_option
  @database_name_option ||= options[:database] ||
                              Threaded.database_override ||
                              storage_options[:database]
end

def for_child(document)
  if document.is_a?(Class)
    return self if document == (@object.is_a?(Class) ? @object : @object.class)
  elsif document.is_a?(Mongoid::Document)
    return self if document.class == (@object.is_a?(Class) ? @object : @object.class)
  else
    raise ArgumentError, 'must specify a class or a document instance'
  end
  PersistenceContext.new(document, options.merge(document.storage_options))
end

def get(object)
  get_context(object)
end

def get_context(object)
  context_store[object.object_id]
end

def initialize(object, opts = {})
  @object = object
  set_options!(opts)
end

def requested_storage_options
  slice = @options.slice(*Mongoid::Clients::Validators::Storage::VALID_OPTIONS)
  slice.any? ? slice : nil
end

def reusable_client?
  @options.keys == [:client]
end

def set(object, options_or_context)
  existing_context = get_context(object)
  existing_options = if existing_context
    existing_context.options
  else
    {}
  end
  if options_or_context.is_a?(PersistenceContext)
    options_or_context = options_or_context.options
  end
  new_options = existing_options.merge(options_or_context)
  context = PersistenceContext.new(object, new_options)
  store_context(object, context)
end

def set_options!(opts)
  @options ||= opts.each.reduce({}) do |_options, (key, value)|
                 unless VALID_OPTIONS.include?(key.to_sym)
                   raise Errors::InvalidPersistenceOption.new(key.to_sym, VALID_OPTIONS)
                 end
                 value ? _options.merge!(key => value) : _options
               end
end

def store_context(object, context)
  if context.nil?
    context_store.delete(object.object_id)
  else
    context_store[object.object_id] = context
  end
end