module SemanticLogger

def self.[](klass)
  Logger.new(klass)
end

def self.add_appender(**args, &block)
  appender = appenders.add(**args, &block)
  # Start appender thread if it is not already running
  Logger.processor.start
  appender
end

def self.add_signal_handler(log_level_signal = "USR2", thread_dump_signal = "TTIN", gc_log_microseconds = 100_000)
  if log_level_signal
    Signal.trap(log_level_signal) do
      current_level_index = LEVELS.find_index(default_level)
      new_level_index = current_level_index == 0 ? LEVELS.size - 1 : current_level_index - 1
      new_level = LEVELS[new_level_index]
      self.default_level = new_level
      self["SemanticLogger"].warn "Changed global default log level to #{new_level.inspect}"
    end
  end
  if thread_dump_signal
    Signal.trap(thread_dump_signal) do
      logger = SemanticLogger["Thread Dump"]
      Thread.list.each do |thread|
        # MRI re-uses the main thread for signals, JRuby uses `SIGTTIN handler` thread.
        next if defined?(JRuby) && (thread == Thread.current)
        logger.backtrace(thread: thread)
      end
    end
  end
  if gc_log_microseconds && defined?(JRuby)
    listener = SemanticLogger::JRuby::GarbageCollectionLogger.new(gc_log_microseconds)
    Java::JavaLangManagement::ManagementFactory.getGarbageCollectorMXBeans.each do |gcbean|
      gcbean.add_notification_listener(listener, nil, nil)
    end
  end
  true
end

def self.appenders
  Logger.processor.appenders
end

def self.application
  @application
end

def self.application=(application)
  @application = application
end

def self.backtrace_level
  @backtrace_level
end

def self.backtrace_level=(level)
  @backtrace_level = level
  # For performance reasons pre-calculate the level index
  @backtrace_level_index = level.nil? ? 65_535 : Levels.index(level)
end

def self.backtrace_level_index
  @backtrace_level_index
end

def self.clear_appenders!
  Logger.processor.close
end

def self.close
  Logger.processor.close
end

def self.default_level
  @default_level
end

def self.default_level=(level)
  @default_level = level
  # For performance reasons pre-calculate the level index
  @default_level_index = Levels.index(level)
end

def self.default_level_index
  Thread.current[:semantic_logger_silence] || @default_level_index
end

def self.environment
  @environment
end

def self.environment=(environment)
  @environment = environment
end

def self.fast_tag(tag)
  return yield if tag.nil? || tag == ""
  t = Thread.current[:semantic_logger_tags] ||= []
  begin
    t << tag
    yield
  ensure
    t.pop
  end
end

def self.flush
  Logger.processor.flush
end

def self.host
  @host ||= Socket.gethostname.force_encoding("UTF-8")
end

def self.host=(host)
  @host = host
end

def self.lag_check_interval
  Logger.processor.lag_check_interval
end

def self.lag_check_interval=(lag_check_interval)
  Logger.processor.lag_check_interval = lag_check_interval
end

def self.lag_threshold_s
  Logger.processor.lag_threshold_s
end

def self.named_tagged(hash)
  return yield if hash.nil? || hash.empty?
  raise(ArgumentError, "#named_tagged only accepts named parameters (Hash)") unless hash.is_a?(Hash)
  begin
    push_named_tags(hash)
    yield
  ensure
    pop_named_tags
  end
end

def self.named_tags
  if (list = Thread.current[:semantic_logger_named_tags]) && !list.empty?
    if list.size > 1
      list.reduce({}) { |sum, h| sum.merge(h) }
    else
      list.first.clone
    end
  else
    {}
  end
end

def self.on_log(object = nil, &block)
  Logger.subscribe(object, &block)
end

def self.pop_named_tags(quantity = 1)
  t = Thread.current[:semantic_logger_named_tags]
  t&.pop(quantity)
end

def self.pop_tags(quantity = 1)
  t = Thread.current[:semantic_logger_tags]
  t&.pop(quantity)
end

def self.push_named_tags(hash)
  (Thread.current[:semantic_logger_named_tags] ||= []) << hash
  hash
end

def self.push_tags(*tags)
  (Thread.current[:semantic_logger_tags] ||= []).concat(tags)
  tags
end

def self.queue_size
  Logger.processor.queue.size
end

def self.remove_appender(appender)
  return unless appender
  appenders.delete(appender)
  appender.close
end

def self.reopen
  Logger.processor.reopen
end

def self.silence(new_level = :error)
  current_index                            = Thread.current[:semantic_logger_silence]
  Thread.current[:semantic_logger_silence] = Levels.index(new_level)
  yield
ensure
  Thread.current[:semantic_logger_silence] = current_index
end

def self.sync!
  Logger.sync!
end

def self.sync?
  Logger.sync?
end

def self.tagged(*tags, &block)
  return yield if tags.empty?
  # Allow named tags to be passed into the logger
  if tags.size == 1
    tag = tags[0]
    return tag.is_a?(Hash) ? named_tagged(tag, &block) : fast_tag(tag, &block)
  end
  begin
    push_tags(*tags)
    yield
  ensure
    pop_tags(tags.size)
  end
end

def self.tags
  # Since tags are stored on a per thread basis this list is thread-safe
  t = Thread.current[:semantic_logger_tags]
  t.nil? ? [] : t.clone
end