# typed: ignore

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

# TODO: Sqreen::Framework::RequestRecorder misnamed/misplaced?
# TODO: deps?

require 'set'
require 'sqreen/shared_storage'
require 'sqreen/events/request_record'
require 'sqreen/performance_notifications/log_performance'
require 'sqreen/performance_notifications/newrelic'
require 'sqreen/log'
require 'sqreen/runner'

module Sqreen
  # Store event/observations that happened in this request
  module RequestRecorder
    def observed_items
      SharedStorage.get(:observed_items)
    end

    def observed_items=(value)
      SharedStorage.set(:observed_items, value)
    end

    def payload_requests
      SharedStorage.get(:payload_requests)
    end

    def payload_requests=(value)
      SharedStorage.set(:payload_requests, value)
    end

    def only_metric_observation
      SharedStorage.get(:only_metric_observation)
    end

    def only_metric_observation=(value)
      SharedStorage.set(:only_metric_observation, value)
    end

    def clean_request_record
      self.only_metric_observation = true
      self.payload_requests = Set.new
      self.observed_items = Hash.new { |hash, key| hash[key] = [] }
    end

    def observe(what, data, accessors = [], report = true)
      clean_request_record if observed_items.nil?
      self.only_metric_observation = false if report
      observed_items[what] << data
      payload_requests.merge(accessors)
    end

    def close_request_record(queue, observations_queue, payload_creator)
      Sqreen.log.debug { "close_request_record called. observed_items: #{observed_items}" }

      clean_request_record if observed_items.nil?
      if Sqreen.features['use_signals'] || only_metric_observation
        push_metrics(observations_queue, queue)
      end

      if only_metric_observation
        clean_request_record
        return
      end

      # signals require request section to be present
      payload_requests << 'request'
      payload = payload_creator.payload(payload_requests)
      payload[:observed] = observed_items

      queue.push create_request_record(payload)
      clean_request_record
    end

    protected

    def create_request_record(payload)
      RequestRecord.new(payload, redactor)
    end

    def redactor
      return nil unless Sqreen.config_get(:strip_sensitive_data)
      @redactor ||= SensitiveDataRedactor.from_config
    end

    # pushes metric observations to the observations queue
    # and clears the list for the request record
    def push_metrics(observations_queue, event_queue)
      observed_items[:observations].each do |obs|
        observations_queue.push obs
      end
      observed_items[:observations] = []
      return unless observations_queue.size > MAX_OBS_QUEUE_LENGTH / 2
      event_queue.push Sqreen::METRICS_EVENT
    end
  end
end