# typed: ignore

# Copyright (c) 2015 Sqreen. All Rights Reserved.
# Please refer to our terms for more information: https://www.sqreen.com/terms.html

require 'sqreen/aggregated_metric'
require 'sqreen/kit'
require 'sqreen/kit/string_sanitizer'
require 'sqreen/signals/conversions'
require 'sqreen/log/loggable'

module Sqreen
  module Signals
    # see also Sqreen::Legacy::OldEventSubmissionStrategy
    # usage in Sqreen:Session
    class SignalsSubmissionStrategy
      include Sqreen::Log::Loggable

      # @param [Array<Sqreen::AggregatedMetric>] metrics
      def post_metrics(metrics)
        return if metrics.nil? || metrics.empty?

        guarded 'Failed to serialize or submit aggregated metrics' do
          batch = metrics.map do |m|
            Conversions.convert_metric_sample(m)
          end
          client.report_batch(batch)
        end
      end

      # @param _attack [Sqreen::Attack]
      # XXX: unused
      def post_attack(_attack)
        raise NotImplementedError
      end

      # @param request_record [Sqreen::RequestRecord]
      def post_request_record(request_record)
        guarded 'Failed to serialize or submit request record' do
          trace = Conversions.convert_req_record(request_record)
          append_sanitizing_filter(trace)
          client.report_trace(trace)
        end
      end

      # Post an exception to Sqreen for analysis
      # @param exception [RemoteException] Exception and context to be sent over
      def post_sqreen_exception(exception)
        guarded 'Failed to serialize or submit exception', false do
          data = Conversions.convert_exception(exception)
          append_sanitizing_filter(data)
          client.report_signal(data)
        end
      end

      def post_batch(events)
        guarded 'Failed to serialize or submit batch of events' do
          batch = Conversions.convert_batch(events)
          batch.each { |sig_or_trace| append_sanitizing_filter(sig_or_trace) }
          client.report_batch(batch)
        end
      end

      private

      def append_sanitizing_filter(sig_or_trace)
        sig_or_trace.append_to_h_filter Kit::StringSanitizer.method(:sanitize)
      end

      # we don't want exceptions to propagate and kill the worker thread
      def guarded(msg, report = true)
        yield
      rescue StandardError => e
        logger.warn "#{msg}: #{e.message}\n#{e.backtrace.map { |x| "  #{x}" }.join("\n")}"
        post_sqreen_exception(RemoteException.new(e)) if report
      end

      def client
        Sqreen::Kit.auth_signals_client
      end
    end
  end
end