class ActiveRecord::ConnectionAdapters::TrilogyAdapter

def active?
  connection&.ping || false
rescue ::Trilogy::Error
  false
end

def connect
  self.connection = self.class.new_client(@config)
rescue ConnectionNotEstablished => ex
  raise ex.set_pool(@pool)
end

def connection
  @raw_connection
end

def connection=(conn)
  @raw_connection = conn
end

def default_prepared_statements
  false
end

def discard!
  super
  unless connection.nil?
    connection.discard!
    self.connection = nil
  end
end

def disconnect!
  super
  unless connection.nil?
    connection.close
    self.connection = nil
  end
end

def each_hash(result)
  return to_enum(:each_hash, result) unless block_given?
  keys = result.fields.map(&:to_sym)
  result.rows.each do |row|
    hash = {}
    idx = 0
    row.each do |value|
      hash[keys[idx]] = value
      idx += 1
    end
    yield hash
  end
  nil
end

def error_number(exception)
  exception.error_code if exception.respond_to?(:error_code)
end

def full_version
  schema_cache.database_version.full_version_string
end

def get_full_version
  with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
    conn.server_info[:version]
  end
end

def initialize(...)
  super
  # Trilogy ignore `socket` if `host is set. We want the opposite to allow
  # configuring UNIX domain sockets via `DATABASE_URL`.
  @config.delete(:host) if @config[:socket]
end

def initialize_type_map(m)
  super
  m.register_type(%r(char)i) do |sql_type|
    limit = extract_limit(sql_type)
    Type.lookup(:string, adapter: :trilogy, limit: limit)
  end
  m.register_type %r(^enum)i, Type.lookup(:string, adapter: :trilogy)
  m.register_type %r(^set)i,  Type.lookup(:string, adapter: :trilogy)
end

def new_client(config)
  config[:ssl_mode] = parse_ssl_mode(config[:ssl_mode]) if config[:ssl_mode]
  ::Trilogy.new(config)
rescue ::Trilogy::Error => error
  raise translate_connect_error(config, error)
end

def parse_ssl_mode(mode)
  return mode if mode.is_a? Integer
  m = mode.to_s.upcase
  m = "SSL_MODE_#{m}" unless m.start_with? "SSL_MODE_"
  SSL_MODES.fetch(m.to_sym, mode)
end

def quote_string(string)
  with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
    conn.escape(string)
  end
end

def reconnect
  connection&.close
  self.connection = nil
  connect
end

def savepoint_errors_invalidate_transactions?
  true
end

def supports_comments?
  true
end

def supports_comments_in_create?
  true
end

def supports_json?
  !mariadb? && database_version >= "5.7.8"
end

def supports_lazy_transactions?
  true
end

def supports_savepoints?
  true
end

def text_type?(type)
  TYPE_MAP.lookup(type).is_a?(Type::String) || TYPE_MAP.lookup(type).is_a?(Type::Text)
end

def translate_connect_error(config, error)
  case error.error_code
  when ER_DBACCESS_DENIED_ERROR, ER_BAD_DB_ERROR
    ActiveRecord::NoDatabaseError.db_error(config[:database])
  when ER_ACCESS_DENIED_ERROR
    ActiveRecord::DatabaseConnectionError.username_error(config[:username])
  else
    if error.message.include?("TRILOGY_DNS_ERROR")
      ActiveRecord::DatabaseConnectionError.hostname_error(config[:host])
    else
      ActiveRecord::ConnectionNotEstablished.new(error.message)
    end
  end
end

def translate_exception(exception, message:, sql:, binds:)
  if exception.is_a?(::Trilogy::TimeoutError) && !exception.error_code
    return ActiveRecord::AdapterTimeout.new(message, sql: sql, binds: binds, connection_pool: @pool)
  end
  error_code = exception.error_code if exception.respond_to?(:error_code)
  case error_code
  when ER_SERVER_SHUTDOWN
    return ConnectionFailed.new(message, connection_pool: @pool)
  end
  case exception
  when Errno::EPIPE, SocketError, IOError
    return ConnectionFailed.new(message, connection_pool: @pool)
  when ::Trilogy::Error
    if /Connection reset by peer|TRILOGY_CLOSED_CONNECTION|TRILOGY_INVALID_SEQUENCE_ID|TRILOGY_UNEXPECTED_PACKET/.match?(exception.message)
      return ConnectionFailed.new(message, connection_pool: @pool)
    end
  end
  super
end