module ActiveRecord::ConnectionHandling

def append_to_connected_to_stack(entry)
  if shard_swapping_prohibited? && entry[:shard].present?
    raise ArgumentError, "cannot swap `shard` while shard swapping is prohibited."
  end
  connected_to_stack << entry
end

def clear_active_connections!(role = nil)
  deprecation_for_delegation(__method__)
  connection_handler.clear_active_connections!(role)
end

def clear_all_connections!(role = nil)
  deprecation_for_delegation(__method__)
  connection_handler.clear_all_connections!(role)
end

def clear_cache! # :nodoc:
  connection.schema_cache.clear!
end

def clear_query_caches_for_current_thread
  connection_handler.each_connection_pool do |pool|
    pool.connection.clear_query_cache if pool.active_connection?
  end
end

def clear_reloadable_connections!(role = nil)
  deprecation_for_delegation(__method__)
  connection_handler.clear_reloadable_connections!(role)
end

def connected?
  connection_handler.connected?(connection_specification_name, role: current_role, shard: current_shard)
end

def connected_to(role: nil, shard: nil, prevent_writes: false, &blk)
  if self != Base && !abstract_class
    raise NotImplementedError, "calling `connected_to` is only allowed on ActiveRecord::Base or abstract classes."
  end
  if !connection_class? && !primary_class?
    raise NotImplementedError, "calling `connected_to` is only allowed on the abstract class that established the connection."
  end
  unless role || shard
    raise ArgumentError, "must provide a `shard` and/or `role`."
  end
  with_role_and_shard(role, shard, prevent_writes, &blk)
end

def connected_to?(role:, shard: ActiveRecord::Base.default_shard)
  current_role == role.to_sym && current_shard == shard.to_sym
end

def connected_to_many(*classes, role:, shard: nil, prevent_writes: false)
  classes = classes.flatten
  if self != Base || classes.include?(Base)
    raise NotImplementedError, "connected_to_many can only be called on ActiveRecord::Base."
  end
  prevent_writes = true if role == ActiveRecord.reading_role
  append_to_connected_to_stack(role: role, shard: shard, prevent_writes: prevent_writes, klasses: classes)
  yield
ensure
  connected_to_stack.pop
end

def connecting_to(role: default_role, shard: default_shard, prevent_writes: false)
  prevent_writes = true if role == ActiveRecord.reading_role
  append_to_connected_to_stack(role: role, shard: shard, prevent_writes: prevent_writes, klasses: [self])
end

def connection
  retrieve_connection
end

def connection_db_config
  connection_pool.db_config
end

def connection_pool
  connection_handler.retrieve_connection_pool(connection_specification_name, role: current_role, shard: current_shard) || raise(ConnectionNotEstablished)
end

def connection_specification_name
  if !defined?(@connection_specification_name) || @connection_specification_name.nil?
    return self == Base ? Base.name : superclass.connection_specification_name
  end
  @connection_specification_name
end

def connects_to(database: {}, shards: {})
  raise NotImplementedError, "`connects_to` can only be called on ActiveRecord::Base or abstract classes" unless self == Base || abstract_class?
  if database.present? && shards.present?
    raise ArgumentError, "`connects_to` can only accept a `database` or `shards` argument, but not both arguments."
  end
  connections = []
  if shards.empty?
    shards[:default] = database
  end
  self.default_shard = shards.keys.first
  shards.each do |shard, database_keys|
    database_keys.each do |role, database_key|
      db_config = resolve_config_for_connection(database_key)
      self.connection_class = true
      connections << connection_handler.establish_connection(db_config, owner_name: self, role: role, shard: shard.to_sym)
    end
  end
  connections
end

def deprecation_for_delegation(method)
  ActiveRecord.deprecator.warn(<<-MSG.squish)
    Calling `ActiveRecord::Base.#{method} is deprecated. Please
    call the method directly on the connection handler; for
    example: `ActiveRecord::Base.connection_handler.#{method}`.
  MSG
end

def establish_connection(config_or_env = nil)
  config_or_env ||= DEFAULT_ENV.call.to_sym
  db_config = resolve_config_for_connection(config_or_env)
  connection_handler.establish_connection(db_config, owner_name: self, role: current_role, shard: current_shard)
end

def flush_idle_connections!(role = nil)
  deprecation_for_delegation(__method__)
  connection_handler.flush_idle_connections!(role)
end

def mysql2_adapter_class
  ConnectionAdapters::Mysql2Adapter
end

def mysql2_connection(config)
  mysql2_adapter_class.new(config)
end

def postgresql_adapter_class
  ConnectionAdapters::PostgreSQLAdapter
end

def postgresql_connection(config)
  postgresql_adapter_class.new(config)
end

def primary_class? # :nodoc:
  self == Base || application_record_class?
end

def prohibit_shard_swapping(enabled = true)
  prev_value = ActiveSupport::IsolatedExecutionState[:active_record_prohibit_shard_swapping]
  ActiveSupport::IsolatedExecutionState[:active_record_prohibit_shard_swapping] = enabled
  yield
ensure
  ActiveSupport::IsolatedExecutionState[:active_record_prohibit_shard_swapping] = prev_value
end

def remove_connection(name = nil)
  if name
    ActiveRecord.deprecator.warn(<<-MSG.squish)
      The name argument for `#remove_connection` is deprecated without replacement
      and will be removed in Rails 7.2. `#remove_connection` should always be called
      on the connection class directly, which makes the name argument obsolete.
    MSG
  end
  name ||= @connection_specification_name if defined?(@connection_specification_name)
  # if removing a connection that has a pool, we reset the
  # connection_specification_name so it will use the parent
  # pool.
  if connection_handler.retrieve_connection_pool(name, role: current_role, shard: current_shard)
    self.connection_specification_name = nil
  end
  connection_handler.remove_connection_pool(name, role: current_role, shard: current_shard)
end

def resolve_config_for_connection(config_or_env)
  raise "Anonymous class is not allowed." unless name
  connection_name = primary_class? ? Base.name : name
  self.connection_specification_name = connection_name
  Base.configurations.resolve(config_or_env)
end

def retrieve_connection
  connection_handler.retrieve_connection(connection_specification_name, role: current_role, shard: current_shard)
end

def shard_swapping_prohibited?
  ActiveSupport::IsolatedExecutionState[:active_record_prohibit_shard_swapping]
end

def sqlite3_adapter_class
  ConnectionAdapters::SQLite3Adapter
end

def sqlite3_connection(config)
  sqlite3_adapter_class.new(config)
end

def trilogy_adapter_class
  ConnectionAdapters::TrilogyAdapter
end

def trilogy_connection(config)
  configuration = config.dup
  # Set FOUND_ROWS capability on the connection so UPDATE queries returns number of rows
  # matched rather than number of rows updated.
  configuration[:found_rows] = true
  options = [
    configuration[:host],
    configuration[:port],
    configuration[:database],
    configuration[:username],
    configuration[:password],
    configuration[:socket],
    0
  ]
  trilogy_adapter_class.new nil, logger, options, configuration
end

def while_preventing_writes(enabled = true, &block)
  connected_to(role: current_role, prevent_writes: enabled, &block)
end

def with_role_and_shard(role, shard, prevent_writes)
  prevent_writes = true if role == ActiveRecord.reading_role
  append_to_connected_to_stack(role: role, shard: shard, prevent_writes: prevent_writes, klasses: [self])
  return_value = yield
  return_value.load if return_value.is_a? ActiveRecord::Relation
  return_value
ensure
  self.connected_to_stack.pop
end