class Appsignal::Transaction

def add_session_data(given_session_data = nil, &block)
  @session_data.add(given_session_data, &block)
end

def add_session_data_if_nil(given_session_data = nil, &block)
  add_session_data(given_session_data, &block) unless @session_data.value?
end

def add_tags(given_tags = {})
  @tags.merge!(given_tags)
end

def after_create(&block)
  @after_create ||= Set.new
  return @after_create if block.nil?
  @after_create << block
end

def before_complete(&block)
  @before_complete ||= Set.new
  return @before_complete if block.nil?
  @before_complete << block
end

def cleaned_backtrace(backtrace)
  if defined?(::Rails) && Rails.respond_to?(:backtrace_cleaner) && backtrace
    ::Rails.backtrace_cleaner.clean(backtrace, nil)
  else
    backtrace
  end
end

def cleaned_error_message(error)
  case error.class.to_s
  when "PG::UniqueViolation", "ActiveRecord::RecordNotUnique"
    error.message.to_s.gsub(/\)=\(.*\)/, ")=(?)")
  else
    error.message.to_s
  end
end

def clear_current_transaction!
  Thread.current[:appsignal_transaction] = nil
end

def complete
  if discarded?
    Appsignal.internal_logger.debug "Skipping transaction '#{transaction_id}' " \
      "because it was manually discarded."
    return
  end
  # If the transaction is a duplicate, we don't want to finish it,
  # because we want its finish time to be the finish time of the
  # original transaction.
  # Duplicate transactions should always be sampled, as we only
  # create duplicates for errors, which are always sampled.
  should_sample = true
  unless duplicate?
    self.class.last_errors = @error_blocks.keys
    should_sample = @ext.finish(0)
  end
  @error_blocks.each do |error, blocks|
    # Ignore the error that is already set in this transaction.
    next if error == @error_set
    duplicate.tap do |transaction|
      # In the duplicate transaction for each error, set an error
      # with a block that calls all the blocks set for that error
      # in the original transaction.
      transaction.internal_set_error(error) do
        blocks.each { |block| block.call(transaction) }
      end
      transaction.complete
    end
  end
  if @error_set && @error_blocks[@error_set].any?
    self.class.with_transaction(self) do
      @error_blocks[@error_set].each do |block|
        block.call(self)
      end
    end
  end
  run_before_complete_hooks
  sample_data if should_sample
  @completed = true
  @ext.complete
end

def complete_current!
  current.complete
rescue => e
  Appsignal.internal_logger.error(
    "Failed to complete transaction ##{current.transaction_id}. #{e.message}"
  )
ensure
  clear_current_transaction!
end

def completed?
  @completed
end

def create(namespace)
  # Reset the transaction if it was already completed but not cleared
  if Thread.current[:appsignal_transaction]&.completed?
    Thread.current[:appsignal_transaction] = nil
  end
  if Thread.current[:appsignal_transaction].nil?
    # If not, start a new transaction
    set_current_transaction(Appsignal::Transaction.new(namespace))
  else
    transaction = current
    # Otherwise, log the issue about trying to start another transaction
    Appsignal.internal_logger.warn(
      "Trying to start new transaction, but a transaction " \
        "with id '#{transaction.transaction_id}' is already running. " \
        "Using transaction '#{transaction.transaction_id}'."
    )
    # And return the current transaction instead
    transaction
  end
end

def current
  Thread.current[:appsignal_transaction] || NilTransaction.new
end

def current?
  current && !current.nil_transaction?
end

def custom_data
  @custom_data.value
rescue => e
  Appsignal.internal_logger.error("Exception while fetching custom data: #{e.class}: #{e}")
  nil
end

def discard!
  @discarded = true
end

def discarded?
  @discarded == true
end

def duplicate
  new_transaction_id = SecureRandom.uuid
  self.class.new(
    namespace,
    :id => new_transaction_id,
    :ext => @ext.duplicate(new_transaction_id)
  ).tap do |transaction|
    transaction.is_duplicate = true
    transaction.tags = @tags.dup
    transaction.custom_data = @custom_data.dup
    transaction.breadcrumbs = @breadcrumbs.dup
    transaction.params = @params.dup
    transaction.session_data = @session_data.dup
    transaction.headers = @headers.dup
  end
end

def duplicate?
  @is_duplicate
end

def finish_event(name, title, body, body_format = Appsignal::EventFormatter::DEFAULT)
  return if paused?
  @ext.finish_event(
    name,
    title || BLANK,
    body || BLANK,
    body_format || Appsignal::EventFormatter::DEFAULT,
    0
  )
end

def first_formatted_backtrace_line(error)
  backtrace = cleaned_backtrace(error.backtrace)
  first_line = backtrace&.first
  return unless first_line
  captures = BACKTRACE_REGEX.match(first_line)
  return unless captures
  captures.named_captures
    .merge("original" => first_line)
    .tap do |c|
      config = Appsignal.config
      # Strip of whitespace at the end of the gem name
      c["gem"] = c["gem"]&.strip
      # Strip the app path from the path if present
      root_path = config.root_path
      if c["path"].start_with?(root_path)
        c["path"].delete_prefix!(root_path)
        # Relative paths shouldn't start with a slash
        c["path"].delete_prefix!("/")
      end
      # Add revision for linking to the repository from the UI
      c["revision"] = config[:revision]
      # Convert line number to an integer
      c["line"] = c["line"].to_i
    end
end

def initialize(namespace, id: SecureRandom.uuid, ext: nil)
  @transaction_id = id
  @action = nil
  @namespace = namespace
  @paused = false
  @discarded = false
  @completed = false
  @tags = {}
  @breadcrumbs = []
  @store = Hash.new { |hash, key| hash[key] = {} }
  @error_blocks = Hash.new { |hash, key| hash[key] = [] }
  @is_duplicate = false
  @error_set = nil
  @params = Appsignal::SampleData.new(:params)
  @session_data = Appsignal::SampleData.new(:session_data, Hash)
  @headers = Appsignal::SampleData.new(:headers, Hash)
  @custom_data = Appsignal::SampleData.new(:custom_data)
  @ext = ext || Appsignal::Extension.start_transaction(
    @transaction_id,
    @namespace,
    0
  ) || Appsignal::Extension::MockTransaction.new
  run_after_create_hooks
end

def instrument(name, title = nil, body = nil, body_format = Appsignal::EventFormatter::DEFAULT)
  start_event
  yield if block_given?
ensure
  finish_event(name, title, body, body_format)
end

def internal_set_error(error, &block)
  _set_error(error) if @error_blocks.empty?
  if !@error_blocks.include?(error) && @error_blocks.length >= ERRORS_LIMIT
    Appsignal.internal_logger.warn "Appsignal::Transaction#add_error: Transaction has more " \
      "than #{ERRORS_LIMIT} distinct errors. Only the first " \
      "#{ERRORS_LIMIT} distinct errors will be reported."
    return
  end
  @error_blocks[error] << block
  @error_blocks[error].compact!
end

def last_errors
  @last_errors ||= []
end

def nil_transaction?
  false
end

def params
  @params.value
rescue => e
  Appsignal.internal_logger.error("Exception while fetching params: #{e.class}: #{e}")
  nil
end

def pause!
  @paused = true
end

def paused?
  @paused == true
end

def record_event(name, title, body, duration, body_format = Appsignal::EventFormatter::DEFAULT)
  return if paused?
  @ext.record_event(
    name,
    title || BLANK,
    body || BLANK,
    body_format || Appsignal::EventFormatter::DEFAULT,
    duration,
    0
  )
end

def request_headers
  @headers.value
rescue => e
  Appsignal.internal_logger.error \
    "Exception while fetching headers: #{e.class}: #{e}"
  nil
end

def restore!
  @discarded = false
end

def resume!
  @paused = false
end

def run_after_create_hooks
  self.class.after_create.each do |block|
    block.call(self)
  end
end

def run_before_complete_hooks
  self.class.before_complete.each do |block|
    block.call(self, @error_set)
  end
end

def sample_data
  {
    :params => sanitized_params,
    :environment => sanitized_request_headers,
    :session_data => sanitized_session_data,
    :tags => sanitized_tags,
    :breadcrumbs => breadcrumbs,
    :custom_data => custom_data
  }.each do |key, data|
    set_sample_data(key, data)
  end
end

def sanitized_params
  return unless Appsignal.config[:send_params]
  filter_keys = Appsignal.config[:filter_parameters] || []
  Appsignal::Utils::SampleDataSanitizer.sanitize(params, filter_keys)
end

def sanitized_request_headers
  headers = request_headers
  return unless headers
  {}.tap do |out|
    Appsignal.config[:request_headers].each do |key|
      out[key] = headers[key] if headers[key]
    end
  end
end

def sanitized_session_data
  return unless Appsignal.config[:send_session_data]
  Appsignal::Utils::SampleDataSanitizer.sanitize(
    session_data,
    Appsignal.config[:filter_session_data]
  )
end

def sanitized_tags
  @tags.select do |key, value|
    ALLOWED_TAG_KEY_TYPES.any? { |type| key.is_a? type } &&
      ALLOWED_TAG_VALUE_TYPES.any? { |type| value.is_a? type }
  end
end

def session_data
  @session_data.value
rescue => e
  Appsignal.internal_logger.error \
    "Exception while fetching session data: #{e.class}: #{e}"
  nil
end

def set_action(action)
  return unless action
  @action = action
  @ext.set_action(action)
end

def set_action_if_nil(action)
  return if @action
  set_action(action)
end

def set_current_transaction(transaction)
  Thread.current[:appsignal_transaction] = transaction
end

def set_empty_params!
  @params.set_empty_value!
end

def set_metadata(key, value)
  return unless key && value
  return if Appsignal.config[:filter_metadata].include?(key.to_s)
  @ext.set_metadata(key, value)
end

def set_namespace(namespace)
  return unless namespace
  @namespace = namespace
  @ext.set_namespace(namespace)
end

def set_queue_start(start)
  return unless start
  @ext.set_queue_start(start)
rescue RangeError
  Appsignal.internal_logger.warn("Queue start value #{start} is too big")
end

def set_sample_data(key, data)
  return unless key && data
  if !data.is_a?(Array) && !data.is_a?(Hash)
    Appsignal.internal_logger.error(
      "Invalid sample data for '#{key}'. Value is not an Array or Hash: '#{data.inspect}'"
    )
    return
  end
  @ext.set_sample_data(
    key.to_s,
    Appsignal::Utils::Data.generate(data)
  )
rescue RuntimeError => e
  begin
    inspected_data = data.inspect
    Appsignal.internal_logger.error(
      "Error generating data (#{e.class}: #{e.message}) for '#{inspected_data}'"
    )
  rescue => e
    Appsignal.internal_logger.error(
      "Error generating data (#{e.class}: #{e.message}). Can't inspect data."
    )
  end
end

def start_event
  return if paused?
  @ext.start_event(0)
end

def store(key)
  @store[key]
end

def to_h
  JSON.parse(@ext.to_json)
end

def with_transaction(transaction)
  original_transaction = current if current?
  set_current_transaction(transaction)
  yield
ensure
  set_current_transaction(original_transaction)
end