class Fart

# File plugins/fart.rb, line 143
def self.build_lag_reply(response_word:, sent_at:, received_at:, ping_ms: nil, server: nil,
                         free_ram: nil, loadavg: nil, uptime: nil, swap: nil, cpu_ns: nil)
  format_reply(
    response_word: response_word,
    timer_ms: lag_from_probe(sent_at: sent_at, received_at: received_at),
    ping_ms: ping_ms,
    server: server,
    free_ram: free_ram,
    loadavg: loadavg,
    uptime: uptime,
    swap: swap,
    cpu_ns: cpu_ns
  )
end

# File plugins/fart.rb, line 158
def self.build_probe_reply(pending, readers: nil)
  system = FartSystem.snapshot(readers: readers || FartSystem.default_readers)
  format_reply(
    response_word: pending[:response_word],
    timer_ms: pending[:lag_ms],
    ping_ms: pending[:ping_ms],
    server: pending[:server],
    free_ram: system[:free_ram],
    loadavg: system[:loadavg],
    uptime: system[:uptime],
    swap: system[:swap],
    cpu_ns: system[:cpu_ns]
  )
end

# File plugins/fart.rb, line 18
def self.command_pattern
  /fart$/i
end

# File plugins/fart.rb, line 53
def self.ctcp_ping_message(token:)
  IrcUserPing.ctcp_ping_message(token: token)
end

# File plugins/fart.rb, line 104
def self.elapsed_ms(start_time, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
  ((clock.call - start_time) * 1000).round
end

# File plugins/fart.rb, line 127
def self.fart(response_word: nil, timer_ms: DEFAULT_TIMER_MS, ping_ms: nil, server: nil,
              free_ram: nil, loadavg: nil, uptime: nil, swap: nil, cpu_ns: nil,
              rand: ->(max) { Random.rand(0...max) })
  format_reply(
    response_word: response_word || pick_response_word(rand: rand),
    timer_ms: timer_ms,
    ping_ms: ping_ms,
    server: server,
    free_ram: free_ram,
    loadavg: loadavg,
    uptime: uptime,
    swap: swap,
    cpu_ns: cpu_ns
  )
end

# File plugins/fart.rb, line 112
def self.format_reply(response_word:, timer_ms: DEFAULT_TIMER_MS, ping_ms: nil, server: nil,
                      free_ram: nil, loadavg: nil, uptime: nil, swap: nil, cpu_ns: nil)
  FartReport.format_reply(
    response_word: response_word,
    lag_ms: timer_ms,
    ping_ms: ping_ms,
    server: server,
    free_ram: free_ram,
    loadavg: loadavg,
    uptime: uptime,
    swap: swap,
    cpu_ns: cpu_ns
  )
end

# File plugins/fart.rb, line 108
def self.lag_from_probe(sent_at:, received_at:)
  elapsed_ms(sent_at, clock: -> { received_at })
end

# File plugins/fart.rb, line 41
def self.lag_probe_command(timestamp:)
  "#{LAG_PROBE_PREFIX}#{lag_probe_token(timestamp)}"
end

# File plugins/fart.rb, line 75
def self.lag_probe_error?(params, prefix: LAG_PROBE_PREFIX)
  unknown_command_from_error(params).start_with?(prefix)
end

# File plugins/fart.rb, line 37
def self.lag_probe_token(timestamp)
  (timestamp.to_f * 1_000_000).round
end

# File plugins/fart.rb, line 57
def self.parse_lag_probe_token(command)
  match = command.to_s.match(/\A#{LAG_PROBE_PREFIX}(\d+)\z/)
  return nil unless match

  match[1].to_i
end

# File plugins/fart.rb, line 64
def self.parse_pong_token(param)
  match = param.to_s.sub(/\A:/, "").match(/\A#{LAG_PROBE_PREFIX}(\d+)\z/)
  return nil unless match

  match[1].to_i
end

# File plugins/fart.rb, line 79
def self.pending_store
  FartProbe.pending_store
end

# File plugins/fart.rb, line 33
def self.pick_response_word(rand: ->(max) { Random.rand(0...max) })
  RESPONSE_WORDS[rand.call(RESPONSE_WORDS.length)]
end

# File plugins/fart.rb, line 45
def self.ping_command(timestamp:)
  "PING :#{LAG_PROBE_PREFIX}#{lag_probe_token(timestamp)}"
end

# File plugins/fart.rb, line 173
def self.record_lag_probe!(token, received_at:, store: pending_store)
  FartProbe.record_lag!(
    token,
    received_at: received_at,
    lag_from_probe: method(:lag_from_probe),
    store: store
  )
end

# File plugins/fart.rb, line 186
def self.record_user_ctcp_ping!(nick:, args:, received_at:, store: pending_store)
  FartProbe.record_user_ctcp_ping!(
    nick: nick,
    args: args,
    received_at: received_at,
    store: store
  )
end

# File plugins/fart.rb, line 182
def self.record_user_pong!(params, received_at:, store: pending_store)
  FartProbe.record_user_pong!(params, received_at: received_at, store: store)
end

# File plugins/fart.rb, line 88
def self.register_pending(token, response_word:, sent_at:, nick:, message: nil, server: nil, store: pending_store)
  FartProbe.register_pending(
    token,
    response_word: response_word,
    sent_at: sent_at,
    nick: nick,
    message: message,
    server: server,
    store: store
  )
end

# File plugins/fart.rb, line 83
def self.reset_pending!(store: {})
  FartProbe.reset!(store: store)
  IrcUserPing.reset!
end

# File plugins/fart.rb, line 100
def self.take_pending(token, store: pending_store)
  FartProbe.take_pending(token, store: store)
end

# File plugins/fart.rb, line 195
def self.timeout_pending(token, received_at:, store: pending_store)
  FartProbe.timeout_pending(
    token,
    received_at: received_at,
    lag_from_probe: method(:lag_from_probe),
    store: store
  )
end

# File plugins/fart.rb, line 71
def self.unknown_command_from_error(params)
  Array(params)[1].to_s
end

# File plugins/fart.rb, line 49
def self.user_ping_command(nick:, token:)
  IrcUserPing.user_ping_command(nick: nick, token: token)
end

# File plugins/fart.rb, line 255
def ctcp_ping(m, *args)
  pending = self.class.record_user_ctcp_ping!(
    nick: m.user.nick,
    args: args,
    received_at: monotonic_now
  )
  deliver_pending_reply!(pending) if pending
end

# File plugins/fart.rb, line 208
def execute(m)
  response_word = self.class.pick_response_word
  sent_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
  token = self.class.lag_probe_token(sent_at)
  server = bot.config.server

  self.class.register_pending(
    token,
    response_word: response_word,
    sent_at: sent_at,
    nick: m.user.nick,
    message: m,
    server: server
  )
  IrcUserPing.register!(nick: m.user.nick, sent_at: sent_at, context: token)
  schedule_probe_timeout(token)
  bot.irc.send(self.class.user_ping_command(nick: m.user.nick, token: token))
  bot.irc.send(self.class.lag_probe_command(timestamp: sent_at))
end

# File plugins/fart.rb, line 204
def fart(**options)
  self.class.fart(**options)
end

# File plugins/fart.rb, line 228
def on_pong(m)
  received_at = monotonic_now
  params = Array(m.params)

  token = self.class.parse_pong_token(params.first)
  if token
    pending = self.class.record_lag_probe!(token, received_at: received_at)
    return deliver_pending_reply!(pending) if pending
  end

  pending = self.class.record_user_pong!(params, received_at: received_at)
  deliver_pending_reply!(pending) if pending
end

# File plugins/fart.rb, line 242
def on_unknown_command(m)
  return unless self.class.lag_probe_error?(m.params)

  token = self.class.parse_lag_probe_token(self.class.unknown_command_from_error(m.params))
  return unless token

  pending = self.class.record_lag_probe!(
    token,
    received_at: monotonic_now
  )
  deliver_pending_reply!(pending) if pending
end