module RabbotMetaQueue

# File lib/rabbot_meta_queue.rb, line 182
def acquire_drain_lock
  @mutex.synchronize do
    if @drain_active
      return false if @drain_thread&.alive?

      @drain_active = false
      @drain_thread = nil
    end

    @drain_active = true
    @drain_thread = Thread.current
    @worker_running = true unless @queue.empty?
    true
  end
end

# File lib/rabbot_meta_queue.rb, line 226
def all_job_metadata
  jobs = @queue.map { |job| job_metadata(job) }
  jobs.unshift(job_metadata(@current_job)) if @current_job
  jobs
end

# File lib/rabbot_meta_queue.rb, line 222
def busy_jobs
  @mutex.synchronize { all_job_metadata }
end

# File lib/rabbot_meta_queue.rb, line 112
def clear_waiting!
  @mutex.synchronize do
    count = @queue.length
    @queue = []
    reconcile_worker_locked! unless @drain_active && @drain_thread&.alive?
    count
  end
end

# File lib/rabbot_meta_queue.rb, line 60
def current_job
  @mutex.synchronize { job_metadata(@current_job) }
end

# File lib/rabbot_meta_queue.rb, line 142
def drain
  return unless acquire_drain_lock

  begin
    loop do
      work = @mutex.synchronize { @queue.shift }
      break unless work

      begin
        @mutex.synchronize { @current_job = work }
        work.block.call
      rescue StandardError => e
        warn "[rabbot] rabbot_meta_queue job failed: #{e.class}: #{e.message}"
        warn e.backtrace.join("\n") if ENV["RABBOT_DEBUG"] == "1"
        begin
          work.on_fail&.call(e)
        rescue StandardError => notify_error
          warn "[rabbot] rabbot_meta_queue on_fail failed: #{notify_error.class}: #{notify_error.message}"
        end
      ensure
        @mutex.synchronize { @current_job = nil if @current_job == work }
      end
    end
  ensure
    should_restart = false
    @mutex.synchronize do
      @drain_active = false
      @drain_thread = nil
      if @queue.any?
        @worker_running = true
        should_restart = true
      else
        @worker_running = false
      end
    end
    drain if should_restart
    schedule_followup! if kick_needed?
  end
end

# File lib/rabbot_meta_queue.rb, line 48
def drain_active?
  @mutex.synchronize { @drain_active }
end

# File lib/rabbot_meta_queue.rb, line 121
def enqueue(on_fail: nil, build_kind: nil, plugin_name: nil, description: nil, &block)
  @mutex.synchronize do
    position = @queue.length + 1
    deferred = !(position == 1 && !@worker_running)
    @queue << Job.new(
      block: block,
      on_fail: on_fail,
      build_kind: build_kind,
      plugin_name: plugin_name,
      description: description,
      deferred: deferred
    )
    if position == 1 && !@worker_running
      @worker_running = true
      [:start, position]
    else
      [:queued, position]
    end
  end
end

# File lib/rabbot_meta_queue.rb, line 102
def followup_scheduler=(callable)
  @followup_scheduler = callable
end

# File lib/rabbot_meta_queue.rb, line 212
def format_queued_reply(position:)
  display_position = position
  display_position += 1 if in_flight_build?
  [
    RabbotMetaBuild.build_tagged_line(IrcFormat.menu_heading("build queued", style: STYLE_TITLE)),
    BUSY_MESSAGE,
    IrcFormat.accent_paren("queued", "position #{display_position}")
  ].join("\n")
end

# File lib/rabbot_meta_queue.rb, line 52
def in_flight_build?
  @mutex.synchronize { in_flight_build_locked? }
end

# File lib/rabbot_meta_queue.rb, line 199
def in_flight_build_locked?
  @worker_running && @drain_active && @drain_thread&.alive?
end

# File lib/rabbot_meta_queue.rb, line 233
def job_metadata(job)
  return nil if job.nil?

  {
    build_kind: job.build_kind,
    plugin_name: job.plugin_name,
    description: job.description,
    deferred: job.deferred == true
  }
end

# File lib/rabbot_meta_queue.rb, line 90
def kick_needed?
  @mutex.synchronize do
    next false if @queue.empty?

    !(@drain_active && @drain_thread&.alive?)
  end
end

# File lib/rabbot_meta_queue.rb, line 245
def name_in_description?(plugin_name, description)
  text = description.to_s
  return false if text.strip.empty?

  text.match?(/\b#{Regexp.escape(plugin_name.to_s)}\b/i)
end

# File lib/rabbot_meta_queue.rb, line 56
def pending_count
  @mutex.synchronize { @queue.length }
end

# File lib/rabbot_meta_queue.rb, line 79
def pending_new_build_for?(normalized_name)
  name = normalized_name.to_s.strip.downcase
  return false if name.empty?

  @mutex.synchronize do
    all_job_metadata.any? do |job|
      job[:build_kind].to_sym == :new && name_in_description?(name, job[:description])
    end
  end
end

# File lib/rabbot_meta_queue.rb, line 68
def plugin_busy?(normalized_name)
  name = normalized_name.to_s.strip.downcase
  return false if name.empty?

  @mutex.synchronize do
    all_job_metadata.any? do |job|
      job[:plugin_name].to_s.downcase == name && job[:build_kind].to_sym == :enhance
    end
  end
end

# File lib/rabbot_meta_queue.rb, line 98
def reconcile_worker!
  @mutex.synchronize { reconcile_worker_locked! }
end

# File lib/rabbot_meta_queue.rb, line 204
def reconcile_worker_locked!
  return if @queue.any?
  return if in_flight_build_locked?

  @worker_running = false
end

# File lib/rabbot_meta_queue.rb, line 33
def reset!
  @mutex.synchronize do
    @queue = []
    @worker_running = false
    @drain_active = false
    @drain_thread = nil
    @followup_scheduler = nil
    @current_job = nil
  end
end

# File lib/rabbot_meta_queue.rb, line 106
def schedule_followup!
  scheduler = @followup_scheduler
  scheduler&.call
end

# File lib/rabbot_meta_queue.rb, line 64
def scheduled_jobs
  @mutex.synchronize { @queue.map { |job| job_metadata(job) } }
end

# File lib/rabbot_meta_queue.rb, line 44
def worker_running?
  @mutex.synchronize { @worker_running }
end