module Blazer

# File lib/blazer.rb, line 242
def self.adapters
  @adapters ||= {}
end

# File lib/blazer.rb, line 250
def self.anomaly_detectors
  @anomaly_detectors ||= {}
end

# File lib/blazer.rb, line 266
def self.archive_queries
  raise "Audits must be enabled to archive" unless Blazer.audit
  raise "Missing status column - see https://github.com/ankane/blazer#23" unless Blazer::Query.column_names.include?("status")

  viewed_query_ids = Blazer::Audit.where("created_at > ?", 90.days.ago).group(:query_id).count.keys.compact
  Blazer::Query.active.where.not(id: viewed_query_ids).update_all(status: "archived")
end

# File lib/blazer.rb, line 127
def self.data_sources
  @data_sources ||= begin
    ds = Hash.new { |hash, key| raise Blazer::Error, "Unknown data source: #{key}" }
    settings["data_sources"].each do |id, s|
      ds[id] = Blazer::DataSource.new(id, s)
    end
    ds
  end
end

# File lib/blazer.rb, line 258
def self.forecasters
  @forecasters ||= {}
end

# File lib/blazer.rb, line 221
def self.maps?
  mapbox_access_token.present? && mapbox_access_token.start_with?("pk.")
end

# File lib/blazer.rb, line 275
def self.monotonic_time
  Process.clock_gettime(Process::CLOCK_MONOTONIC)
end

# File lib/blazer.rb, line 246
def self.register_adapter(name, adapter)
  adapters[name] = adapter
end

# File lib/blazer.rb, line 254
def self.register_anomaly_detector(name, &anomaly_detector)
  anomaly_detectors[name] = anomaly_detector
end

# File lib/blazer.rb, line 262
def self.register_forecaster(name, &forecaster)
  forecasters[name] = forecaster
end

# File lib/blazer.rb, line 146
def self.run_check(check)
  tries = 1

  ActiveSupport::Notifications.instrument("run_check.blazer", check_id: check.id, query_id: check.query.id, state_was: check.state) do |instrument|
    # try 3 times on timeout errors
    statement = check.query.statement_object
    data_source = statement.data_source

    while tries <= 3
      result = data_source.run_statement(statement, refresh_cache: true, check: check, query: check.query)
      if result.timed_out?
        Rails.logger.info "[blazer timeout] query=#{check.query.name}"
        tries += 1
        sleep(10)
      elsif result.error.to_s.start_with?("PG::ConnectionBad")
        data_source.reconnect
        Rails.logger.info "[blazer reconnect] query=#{check.query.name}"
        tries += 1
        sleep(10)
      else
        break
      end
    end

    begin
      check.reload # in case state has changed since job started
      check.update_state(result)
    rescue ActiveRecord::RecordNotFound
      # check deleted
    end

    # TODO use proper logfmt
    Rails.logger.info "[blazer check] query=#{check.query.name} state=#{check.state} rows=#{result.rows.try(:size)} error=#{result.error}"

    # should be no variables
    instrument[:statement] = statement.bind_statement
    instrument[:data_source] = data_source
    instrument[:state] = check.state
    instrument[:rows] = result.rows.try(:size)
    instrument[:error] = result.error
    instrument[:tries] = tries
  end
end

# File lib/blazer.rb, line 137
def self.run_checks(schedule: nil)
  checks = Blazer::Check.includes(:query)
  checks = checks.where(schedule: schedule) if schedule
  checks.find_each do |check|
    next if check.state == "disabled"
    Safely.safely { run_check(check) }
  end
end

# File lib/blazer.rb, line 190
def self.send_failing_checks
  emails = {}
  slack_channels = {}

  Blazer::Check.includes(:query).where(state: ["failing", "error", "timed out", "disabled"]).find_each do |check|
    check.split_emails.each do |email|
      (emails[email] ||= []) << check
    end
    check.split_slack_channels.each do |channel|
      (slack_channels[channel] ||= []) << check
    end
  end

  emails.each do |email, checks|
    Safely.safely do
      Blazer::CheckMailer.failing_checks(email, checks).deliver_now
    end
  end

  slack_channels.each do |channel, checks|
    Safely.safely do
      Blazer::SlackNotifier.failing_checks(channel, checks)
    end
  end
end

# File lib/blazer.rb, line 116
def self.settings
  @settings ||= begin
    path = Rails.root.join("config", "blazer.yml").to_s
    if File.exist?(path)
      YAML.safe_load(ERB.new(File.read(path)).result, aliases: true)
    else
      {}
    end
  end
end

# File lib/blazer.rb, line 216
def self.slack?
  slack_oauth_token.present? || slack_webhook_url.present?
end

# File lib/blazer.rb, line 95
def self.time_zone=(time_zone)
  @time_zone = time_zone.is_a?(ActiveSupport::TimeZone) ? time_zone : ActiveSupport::TimeZone[time_zone.to_s]
end

# File lib/blazer.rb, line 225
def self.uploads?
  settings.key?("uploads")
end

# File lib/blazer.rb, line 229
def self.uploads_connection
  raise "Empty url for uploads" unless settings.dig("uploads", "url")
  Blazer::UploadsConnection.connection
end

# File lib/blazer.rb, line 234
def self.uploads_schema
  settings.dig("uploads", "schema") || "uploads"
end

# File lib/blazer.rb, line 238
def self.uploads_table_name(name)
  uploads_connection.quote_table_name("#{uploads_schema}.#{name}")
end

# File lib/blazer.rb, line 99
def self.user_class
  if !defined?(@user_class)
    @user_class = settings.key?("user_class") ? settings["user_class"] : (User.name rescue nil)
  end
  @user_class
end

# File lib/blazer.rb, line 106
def self.user_method
  if !defined?(@user_method)
    @user_method = settings["user_method"]
    if user_class
      @user_method ||= "current_#{user_class.to_s.downcase.singularize}"
    end
  end
  @user_method
end