# frozen_string_literal: true

require "io/wait"

module IOExtensions
  refine IO do
    # provides a fallback for rubies where IO#wait isn't implemented,
    # but IO#wait_readable and IO#wait_writable are.
    def wait(timeout = nil, _mode = :read_write)
      r, w = IO.select([self], [self], nil, timeout)

      return unless r || w

      self
    end
  end
end

class HTTPX::Selector
  READABLE = %i[rw r].freeze
  WRITABLE = %i[rw w].freeze

  private_constant :READABLE
  private_constant :WRITABLE

  using IOExtensions unless IO.method_defined?(:wait) && IO.instance_method(:wait).arity == 2

  def initialize
    @selectables = []
  end

  # deregisters +io+ from selectables.
  def deregister(io)
    @selectables.delete(io)
  end

  # register +io+.
  def register(io)
    return if @selectables.include?(io)

    @selectables << io
  end

  private

  READ_INTERESTS = %i[r rw].freeze
  WRITE_INTERESTS = %i[w rw].freeze

  def select_many(interval, &block)
    selectables, r, w = nil

    # first, we group IOs based on interest type. On call to #interests however,
    # things might already happen, and new IOs might be registered, so we might
    # have to start all over again. We do this until we group all selectables
    loop do
      begin
        r = nil
        w = nil

        selectables = @selectables
        @selectables = []

        selectables.each do |io|
          interests = io.interests

          (r ||= []) << io if READ_INTERESTS.include?(interests)
          (w ||= []) << io if WRITE_INTERESTS.include?(interests)
        end

        if @selectables.empty?
          @selectables = selectables

          # do not run event loop if there's nothing to wait on.
          # this might happen if connect failed and connection was unregistered.
          return if (!r || r.empty?) && (!w || w.empty?)

          break
        else
          @selectables = [*selectables, @selectables]
        end
      rescue StandardError
        @selectables = selectables if selectables
        raise
      end
    end

    # TODO: what to do if there are no selectables?

    begin
      readers, writers = IO.select(r, w, nil, interval)

      raise HTTPX::TimeoutError.new(interval, "timed out while waiting on select") if readers.nil? && writers.nil?
    rescue IOError, SystemCallError
      @selectables.reject!(&:closed?)
      retry
    end

    readers.each do |io|
      yield io

      # so that we don't yield 2 times
      writers.delete(io)
    end if readers

    writers.each(&block) if writers
  end

  def select_one(interval)
    io = @selectables.first

    interests = io.interests

    result = case interests
             when :r then io.to_io.wait_readable(interval)
             when :w then io.to_io.wait_writable(interval)
             when :rw then io.to_io.wait(interval, :read_write)
             when nil then return
    end

    raise HTTPX::TimeoutError.new(interval, "timed out while waiting on select") unless result

    yield io
  rescue IOError, SystemCallError
    @selectables.reject!(&:closed?)
    raise unless @selectables.empty?
  end

  def select(interval, &block)
    return select_one(interval, &block) if @selectables.size == 1

    select_many(interval, &block)
  end

  public :select
end