module Mongoid::Config

def clients
  @clients ||= {}
end

def clients=(clients)
  raise Errors::NoClientsConfig.new unless clients
  c = clients.with_indifferent_access
  Validators::Client.validate(c)
  @clients = c
end

def config
  self
end

def configured?
  clients.key?(:default)
end

def connect_to(name, options = { read: { mode: :primary }})
  self.clients = {
    default: {
      database: name,
      hosts: [ "localhost:27017" ],
      options: options
    }
  }
end

def deregister_model(klass)
  LOCK.synchronize do
    models.delete(klass)
  end
end

def destructive_fields
  Composable.prohibited_methods
end

def global_client
  client =  if Threaded.client_override
              Clients.with_name(Threaded.client_override)
            else
              Clients.default
            end
  if Threaded.database_override
    client.use(Threaded.database_override)
  else
    client
  end
end

def load!(path, environment = nil)
  settings = Environment.load_yaml(path, environment)
  if settings.present?
    Clients.disconnect
    Clients.clear
    load_configuration(settings)
  end
  settings
end

def load_configuration(settings)
  configuration = settings.with_indifferent_access
  self.options = configuration[:options]
  self.clients = configuration[:clients]
  Mongo.options = configuration[:driver_options] || {}
  set_log_levels
end

def models
  @models ||= []
end

def options=(options)
  if options
    Validators::AsyncQueryExecutor.validate(options)
    options.each_pair do |option, value|
      Validators::Option.validate(option)
      send("#{option}=", value)
    end
  end
end

def override_client(name)
  Threaded.client_override = name ? name.to_s : nil
end

def override_database(name)
  Threaded.database_override = name
end

def purge!
  global_client.database.collections.each(&:drop) and true
end

def register_model(klass)
  LOCK.synchronize do
    models.push(klass) unless models.include?(klass)
  end
end

def running_with_passenger?
  @running_with_passenger ||= defined?(PhusionPassenger)
end

def set_log_levels
  Mongoid.logger.level = Mongoid::Config.log_level unless defined?(::Rails)
  Mongo::Logger.logger.level = Mongoid.logger.level
end

def time_zone
  use_utc? ? "UTC" : ::Time.zone
end

def truncate!
  global_client.database.collections.each do |collection|
    collection.find.delete_many
  end and true
end