module Airbrake

def add_filter(filter = nil, &block)
  notice_notifier.add_filter(filter, &block)
end

def add_performance_filter(filter = nil, &block)
  performance_notifier.add_filter(filter, &block)
end

def build_notice(exception, params = {})
  notice_notifier.build_notice(exception, params)
end

def close
  if defined?(@notice_notifier) && @notice_notifier
    @notice_notifier.close
  end
  if defined?(@performance_notifier) && @performance_notifier
    @performance_notifier.close
  end
  if defined?(@remote_settings) && @remote_settings
    @remote_settings.stop_polling
  end
  nil
end

def configure
  yield config = Airbrake::Config.instance
  Airbrake::Loggable.instance = config.logger
  config_processor = Airbrake::Config::Processor.new(config)
  config_processor.process_blocklist(notice_notifier)
  config_processor.process_allowlist(notice_notifier)
  @remote_settings ||= config_processor.process_remote_configuration
  config_processor.add_filters(notice_notifier)
end

def configured?
  @notice_notifier && @notice_notifier.configured?
end

def delete_filter(filter_class)
  notice_notifier.delete_filter(filter_class)
end

def delete_performance_filter(filter_class)
  performance_notifier.delete_filter(filter_class)
end

def deploy_notifier
  @deploy_notifier ||= DeployNotifier.new
end

def merge_context(context)
  notice_notifier.merge_context(context)
end

def notice_notifier
  @notice_notifier ||= NoticeNotifier.new
end

def notify(exception, params = {}, &block)
  notice_notifier.notify(exception, params, &block)
end

def notify_deploy(deploy_info)
  deploy_notifier.notify(deploy_info)
end

def notify_performance_breakdown: (method | String | route | String | response_type | Symbol | groups | db | Float | view | Float | timing | Float | time | Float breakdown_info, ?request | ActionDispatch::Request | user | id | String | name | String | email | String stash) -> untyped

def notify_performance_breakdown(breakdown_info, stash = {})
  performance_breakdown = PerformanceBreakdown.new(**breakdown_info)
  performance_breakdown.stash.merge!(stash)
  performance_notifier.notify(performance_breakdown)
end

def notify_performance_breakdown_sync(breakdown_info, stash = {})
  performance_breakdown = PerformanceBreakdown.new(**breakdown_info)
  performance_breakdown.stash.merge!(stash)
  performance_notifier.notify_sync(performance_breakdown)
end

def notify_query: (route | String | method | String | query | String | func | String | file | String | line | Integer | timing | Float | time | Float query_info, ? stash) -> untyped

def notify_query(query_info, stash = {})
  query = Query.new(**query_info)
  query.stash.merge!(stash)
  performance_notifier.notify(query)
end

def notify_query_sync(query_info, stash = {})
  query = Query.new(**query_info)
  query.stash.merge!(stash)
  performance_notifier.notify_sync(query)
end

def notify_queue(queue_info, stash = {})
  queue = Queue.new(**queue_info)
  queue.stash.merge!(stash)
  performance_notifier.notify(queue)
end

def notify_queue_sync(queue_info, stash = {})
  queue = Queue.new(**queue_info)
  queue.stash.merge!(stash)
  performance_notifier.notify_sync(queue)
end

def notify_request: (method | String | route | String | status_code | Integer | timing | Float | time | Float request_info, ? stash) -> untyped

def notify_request(request_info, stash = {})
  request = Request.new(**request_info)
  request.stash.merge!(stash)
  performance_notifier.notify(request)
end

def notify_request_sync(request_info, stash = {})
  request = Request.new(**request_info)
  request.stash.merge!(stash)
  performance_notifier.notify_sync(request)
end

def notify_sync(exception, params = {}, &block)
  notice_notifier.notify_sync(exception, params, &block)
end

def performance_notifier: () -> untyped

def performance_notifier
  @performance_notifier ||= PerformanceNotifier.new
end

def reset
  close
  self.performance_notifier = PerformanceNotifier.new
  self.notice_notifier = NoticeNotifier.new
  self.deploy_notifier = DeployNotifier.new
end